@rian8337/osu-difficulty-calculator 4.0.0-beta.11 → 4.0.0-beta.13

package/dist/index.js

@@ -563,7 +563,7 @@ class DifficultyHitObjectCreator {
 }
 
 /**
- * The base of difficulty calculators.
+ * The base of a difficulty calculator.
  */
 class DifficultyCalculator {
     /**
@@ -626,8 +626,8 @@ class DifficultyCalculator {
             od: this.beatmap.difficulty.od,
             hp: this.beatmap.difficulty.hp,
             mods: options?.mods,
-            speedMultiplier: options?.stats?.speedMultiplier,
-            oldStatistics: options?.stats?.oldStatistics,
+            speedMultiplier: options?.stats?.speedMultiplier ?? 1,
+            oldStatistics: options?.stats?.oldStatistics ?? false,
         }).calculate({ mode: this.mode });
         this.preProcess();
         this.populateDifficultyAttributes();
@@ -661,15 +661,11 @@ class DifficultyCalculator {
      */
     calculateSkills(...skills) {
         // The first object doesn't generate a strain, so we begin calculating from the second object.
-        this.objects.slice(1).forEach((h, i) => {
-            skills.forEach((skill) => {
-                skill.process(h);
-                if (i === this.objects.length - 2) {
-                    // Don't forget to save the last strain peak, which would otherwise be ignored.
-                    skill.saveCurrentPeak();
-                }
-            });
-        });
+        for (const object of this.objects.slice(1)) {
+            for (const skill of skills) {
+                skill.process(object);
+            }
+        }
     }
     /**
      * Populates the stored difficulty attributes with necessary data.
@@ -709,12 +705,9 @@ class DroidAimEvaluator extends AimEvaluator {
     static wideAngleMultiplier = 1.65;
     static sliderMultiplier = 1.5;
     static velocityChangeMultiplier = 0.85;
-    /**
-     * Spacing threshold for a single hitobject spacing.
-     */
-    static SINGLE_SPACING_THRESHOLD = 175;
-    // ~200 1/2 BPM jumps
-    static minSpeedBonus = 150;
+    static singleSpacingThreshold = 100;
+    // 200 1/4 BPM delta time
+    static minSpeedBonus = 75;
     /**
      * Evaluates the difficulty of aiming the current object, based on:
      *
@@ -732,13 +725,13 @@ class DroidAimEvaluator extends AimEvaluator {
             current.isOverlapping(true)) {
             return 0;
         }
-        return (this.aimStrainOf(current, withSliders) +
-            this.movementStrainOf(current));
+        return (this.snapAimStrainOf(current, withSliders) +
+            this.flowAimStrainOf(current));
     }
     /**
-     * Calculates the aim strain of a hitobject.
+     * Calculates the snap aim strain of a hitobject.
      */
-    static aimStrainOf(current, withSliders) {
+    static snapAimStrainOf(current, withSliders) {
         if (current.index <= 1 ||
             current.previous(0)?.object instanceof osuBase.Spinner) {
             return 0;
@@ -848,21 +841,18 @@ class DroidAimEvaluator extends AimEvaluator {
         return strain;
     }
     /**
-     * Calculates the movement strain of a hitobject.
+     * Calculates the flow aim strain of a hitobject.
      */
-    static movementStrainOf(current) {
+    static flowAimStrainOf(current) {
         let speedBonus = 1;
         if (current.strainTime < this.minSpeedBonus) {
             speedBonus +=
                 0.75 *
-                    Math.pow((this.minSpeedBonus - current.strainTime) / 45, 2);
+                    Math.pow((this.minSpeedBonus - current.strainTime) / 40, 2);
         }
         const travelDistance = current.previous(0)?.travelDistance ?? 0;
-        const distance = Math.min(this.SINGLE_SPACING_THRESHOLD, travelDistance + current.minimumJumpDistance);
-        return ((50 *
-            speedBonus *
-            Math.pow(distance / this.SINGLE_SPACING_THRESHOLD, 5)) /
-            current.strainTime);
+        const shortDistancePenalty = Math.pow(Math.min(this.singleSpacingThreshold, travelDistance + current.minimumJumpDistance) / this.singleSpacingThreshold, 3.5);
+        return (200 * speedBonus * shortDistancePenalty) / current.strainTime;
     }
 }
 
@@ -886,25 +876,14 @@ class Skill {
  * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
  */
 class StrainSkill extends Skill {
-    /**
-     * The strain of currently calculated hitobject.
-     */
-    currentStrain = 0;
-    /**
-     * The current section's strain peak.
-     */
-    currentSectionPeak = 0;
     /**
      * Strain peaks are stored here.
      */
     strainPeaks = [];
     sectionLength = 400;
+    currentStrain = 0;
+    currentSectionPeak = 0;
     currentSectionEnd = 0;
-    /**
-     * Calculates the strain value of a hitobject and stores the value in it. This value is affected by previously processed objects.
-     *
-     * @param current The hitobject to process.
-     */
     process(current) {
         // The first object doesn't generate a strain, so we begin with an incremented section end
         if (current.index === 0) {
@@ -921,6 +900,10 @@ class StrainSkill extends Skill {
         this.currentStrain = this.strainValueAt(current);
         this.saveToHitObject(current);
         this.currentSectionPeak = Math.max(this.currentStrain, this.currentSectionPeak);
+        if (!current.next(0)) {
+            // Don't forget to save the last strain peak, which would otherwise be ignored.
+            this.saveCurrentPeak();
+        }
     }
     /**
      * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
@@ -939,15 +922,13 @@ class StrainSkill extends Skill {
     /**
      * Sets the initial strain level for a new section.
      *
-     * @param offset The beginning of the new section in milliseconds, adjusted by speed multiplier.
+     * @param time The beginning of the new section in milliseconds.
      * @param current The current hitobject.
      */
-    startNewSectionFrom(offset, current) {
-        // The maximum strain of the new section is not zero by default, strain decays as usual regardless of section boundaries.
+    startNewSectionFrom(time, current) {
+        // The maximum strain of the new section is not zero by default.
         // This means we need to capture the strain level at the beginning of the new section, and use that as the initial peak level.
-        this.currentSectionPeak =
-            this.currentStrain *
-                this.strainDecay(offset - current.previous(0).startTime);
+        this.currentSectionPeak = this.calculateInitialStrain(time, current);
     }
 }
 
@@ -981,35 +962,37 @@ class DroidSkill extends StrainSkill {
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 class DroidAim extends DroidSkill {
-    skillMultiplier = 24.55;
     strainDecayBase = 0.15;
     reducedSectionCount = 10;
     reducedSectionBaseline = 0.75;
     starsPerDouble = 1.05;
+    skillMultiplier = 24.55;
     withSliders;
+    currentAimStrain = 0;
     constructor(mods, withSliders) {
         super(mods);
         this.withSliders = withSliders;
     }
-    /**
-     * @param current The hitobject to calculate.
-     */
     strainValueAt(current) {
-        this.currentStrain *= this.strainDecay(current.deltaTime);
-        this.currentStrain +=
+        this.currentAimStrain *= this.strainDecay(current.deltaTime);
+        this.currentAimStrain +=
             DroidAimEvaluator.evaluateDifficultyOf(current, this.withSliders) *
                 this.skillMultiplier;
-        return this.currentStrain;
+        return this.currentAimStrain;
+    }
+    calculateInitialStrain(time, current) {
+        return (this.currentAimStrain *
+            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
     }
     /**
      * @param current The hitobject to save to.
      */
     saveToHitObject(current) {
         if (this.withSliders) {
-            current.aimStrainWithSliders = this.currentStrain;
+            current.aimStrainWithSliders = this.currentAimStrain;
         }
         else {
-            current.aimStrainWithoutSliders = this.currentStrain;
+            current.aimStrainWithoutSliders = this.currentAimStrain;
         }
     }
 }
@@ -1047,10 +1030,10 @@ class DroidTapEvaluator extends SpeedEvaluator {
         }
         let doubletapness = 1;
         if (considerCheesability) {
-            const greatWindowFull = greatWindow * 2;
             // Nerf doubletappable doubles.
             const next = current.next(0);
             if (next) {
+                const greatWindowFull = greatWindow * 2;
                 const currentDeltaTime = Math.max(1, current.deltaTime);
                 const nextDeltaTime = Math.max(1, next.deltaTime);
                 const deltaDifference = Math.abs(nextDeltaTime - currentDeltaTime);
@@ -1074,38 +1057,44 @@ 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 {
-    skillMultiplier = 1375;
     reducedSectionCount = 10;
     reducedSectionBaseline = 0.75;
     strainDecayBase = 0.3;
     starsPerDouble = 1.1;
     currentTapStrain = 0;
-    currentOriginalTapStrain = 0;
+    currentRhythmMultiplier = 0;
+    skillMultiplier = 1375;
     greatWindow;
-    constructor(mods, overallDifficulty) {
+    considerCheesability;
+    constructor(mods, overallDifficulty, considerCheesability) {
         super(mods);
         this.greatWindow = new osuBase.OsuHitWindow(overallDifficulty).hitWindowFor300();
+        this.considerCheesability = considerCheesability;
     }
-    /**
-     * @param current The hitobject to calculate.
-     */
     strainValueAt(current) {
         const decay = this.strainDecay(current.strainTime);
         this.currentTapStrain *= decay;
         this.currentTapStrain +=
-            DroidTapEvaluator.evaluateDifficultyOf(current, this.greatWindow, true) * this.skillMultiplier;
-        this.currentOriginalTapStrain *= decay;
-        this.currentOriginalTapStrain +=
-            DroidTapEvaluator.evaluateDifficultyOf(current, this.greatWindow, false) * this.skillMultiplier;
-        this.currentOriginalTapStrain *= current.rhythmMultiplier;
+            DroidTapEvaluator.evaluateDifficultyOf(current, this.greatWindow, this.considerCheesability) * this.skillMultiplier;
+        this.currentRhythmMultiplier = current.rhythmMultiplier;
         return this.currentTapStrain * current.rhythmMultiplier;
     }
+    calculateInitialStrain(time, current) {
+        return (this.currentTapStrain *
+            this.currentRhythmMultiplier *
+            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
+    }
     /**
      * @param current The hitobject to save to.
      */
     saveToHitObject(current) {
-        current.tapStrain = this.currentStrain;
-        current.originalTapStrain = this.currentOriginalTapStrain;
+        const strain = this.currentTapStrain * this.currentRhythmMultiplier;
+        if (this.considerCheesability) {
+            current.tapStrain = strain;
+        }
+        else {
+            current.originalTapStrain = strain;
+        }
     }
 }
 
@@ -1213,33 +1202,36 @@ 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.052;
     strainDecayBase = 0.15;
     reducedSectionCount = 0;
     reducedSectionBaseline = 1;
     starsPerDouble = 1.06;
+    skillMultiplier = 0.052;
     isHidden;
     withSliders;
+    currentFlashlightStrain = 0;
     constructor(mods, withSliders) {
         super(mods);
         this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
         this.withSliders = withSliders;
     }
-    /**
-     * @param current The hitobject to calculate.
-     */
     strainValueAt(current) {
-        this.currentStrain *= this.strainDecay(current.deltaTime);
-        this.currentStrain +=
+        this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
+        this.currentFlashlightStrain +=
             DroidFlashlightEvaluator.evaluateDifficultyOf(current, this.isHidden, this.withSliders) * this.skillMultiplier;
-        return this.currentStrain;
+        return this.currentFlashlightStrain;
+    }
+    calculateInitialStrain(time, current) {
+        return (this.currentFlashlightStrain *
+            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
     }
     saveToHitObject(current) {
         if (this.withSliders) {
-            current.flashlightStrainWithSliders = this.currentStrain;
+            current.flashlightStrainWithSliders = this.currentFlashlightStrain;
         }
         else {
-            current.flashlightStrainWithoutSliders = this.currentStrain;
+            current.flashlightStrainWithoutSliders =
+                this.currentFlashlightStrain;
         }
     }
     difficultyValue() {
@@ -1313,8 +1305,8 @@ class DroidRhythmEvaluator extends RhythmEvaluator {
                     Math.min(0.5, Math.pow(Math.sin(Math.PI /
                         (Math.min(prevDelta, currentDelta) /
                             Math.max(prevDelta, currentDelta))), 2));
-            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - greatWindow * 0.4) /
-                (greatWindow * 0.4));
+            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - greatWindow * 0.6) /
+                (greatWindow * 0.6));
             let effectiveRatio = windowPenalty * currentRatio;
             if (firstDeltaSwitch) {
                 if (prevDelta <= 1.25 * currentDelta &&
@@ -1391,26 +1383,31 @@ class DroidRhythmEvaluator extends RhythmEvaluator {
  * Represents the skill required to properly follow a beatmap's rhythm.
  */
 class DroidRhythm extends DroidSkill {
-    skillMultiplier = 1;
     reducedSectionCount = 5;
     reducedSectionBaseline = 0.75;
     strainDecayBase = 0.3;
     starsPerDouble = 1.75;
-    currentRhythm = 1;
+    currentRhythmStrain = 0;
+    currentRhythmMultiplier = 1;
     hitWindow;
     constructor(mods, overallDifficulty) {
         super(mods);
         this.hitWindow = new osuBase.OsuHitWindow(overallDifficulty);
     }
     strainValueAt(current) {
-        this.currentRhythm = DroidRhythmEvaluator.evaluateDifficultyOf(current, this.hitWindow.hitWindowFor300());
-        this.currentStrain *= this.strainDecay(current.deltaTime);
-        this.currentStrain += this.currentRhythm - 1;
-        return this.currentStrain;
+        this.currentRhythmMultiplier =
+            DroidRhythmEvaluator.evaluateDifficultyOf(current, this.hitWindow.hitWindowFor300());
+        this.currentRhythmStrain *= this.strainDecay(current.deltaTime);
+        this.currentRhythmStrain += this.currentRhythmMultiplier - 1;
+        return this.currentRhythmStrain;
+    }
+    calculateInitialStrain(time, current) {
+        return (this.currentRhythmStrain *
+            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
     }
     saveToHitObject(current) {
-        current.rhythmStrain = this.currentStrain;
-        current.rhythmMultiplier = this.currentRhythm;
+        current.rhythmStrain = this.currentRhythmStrain;
+        current.rhythmMultiplier = this.currentRhythmMultiplier;
     }
 }
 
@@ -1475,12 +1472,14 @@ class DroidVisualEvaluator {
         }
         if (current.object instanceof osuBase.Slider && withSliders) {
             const scalingFactor = 50 / current.object.getRadius(osuBase.Modes.droid);
-            // Reward sliders based on velocity.
+            // Invert the scaling factor to determine the true travel distance independent of circle size.
+            const pixelTravelDistance = current.object.lazyTravelDistance / scalingFactor;
+            const currentVelocity = pixelTravelDistance / current.travelTime;
             strain +=
-                // Avoid overbuffing extremely fast sliders.
-                Math.min(6, current.velocity * 1.5) *
-                    // Scale with distance travelled to avoid overbuffing fast sliders with short distance.
-                    Math.min(1, current.travelDistance / scalingFactor / 125);
+                // Reward sliders based on velocity, while also avoiding overbuffing extremely fast sliders.
+                Math.min(6, currentVelocity * 1.5) *
+                    // Longer sliders require more reading.
+                    (pixelTravelDistance / 100);
             let cumulativeStrainTime = 0;
             // Reward for velocity changes based on last few sliders.
             for (let i = 0; i < Math.min(current.index, 4); ++i) {
@@ -1491,12 +1490,16 @@ class DroidVisualEvaluator {
                     last.isOverlapping(true)) {
                     continue;
                 }
+                // Invert the scaling factor to determine the true travel distance independent of circle size.
+                const pixelTravelDistance = last.object.lazyTravelDistance / scalingFactor;
+                const lastVelocity = pixelTravelDistance / last.travelTime;
                 strain +=
-                    // Avoid overbuffing extremely fast velocity changes.
-                    Math.min(10, 2.5 * Math.abs(current.velocity - last.velocity)) *
-                        // Scale with distance travelled to avoid overbuffing fast sliders with short distance.
-                        Math.min(1, last.travelDistance / scalingFactor / 100) *
-                        // Scale with cumulative strain time to avoid overbuffing past sliders.
+                    // Reward past sliders based on velocity changes, while also
+                    // avoiding overbuffing extremely fast velocity changes.
+                    Math.min(10, 2.5 * Math.abs(currentVelocity - lastVelocity)) *
+                        // Longer sliders require more reading.
+                        (pixelTravelDistance / 125) *
+                        // Avoid overbuffing past sliders.
                         Math.min(1, 300 / cumulativeStrainTime);
             }
         }
@@ -1511,27 +1514,36 @@ class DroidVisual extends DroidSkill {
     starsPerDouble = 1.025;
     reducedSectionCount = 10;
     reducedSectionBaseline = 0.75;
-    skillMultiplier = 10;
     strainDecayBase = 0.1;
     isHidden;
-    withsliders;
+    withSliders;
+    currentVisualStrain = 0;
+    currentRhythmMultiplier = 1;
+    skillMultiplier = 10;
     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 * (1 + (current.rhythmMultiplier - 1) / 5);
+        this.currentVisualStrain *= this.strainDecay(current.deltaTime);
+        this.currentVisualStrain +=
+            DroidVisualEvaluator.evaluateDifficultyOf(current, this.isHidden, this.withSliders) * this.skillMultiplier;
+        this.currentRhythmMultiplier = current.rhythmMultiplier;
+        return this.currentVisualStrain * this.currentRhythmMultiplier;
+    }
+    calculateInitialStrain(time, current) {
+        return (this.currentVisualStrain *
+            this.currentRhythmMultiplier *
+            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
     }
     saveToHitObject(current) {
-        if (this.withsliders) {
-            current.visualStrainWithSliders = this.currentStrain;
+        const strain = this.currentVisualStrain * this.currentRhythmMultiplier;
+        if (this.withSliders) {
+            current.visualStrainWithSliders = strain;
         }
         else {
-            current.visualStrainWithoutSliders = this.currentStrain;
+            current.visualStrainWithoutSliders = strain;
         }
     }
 }
@@ -1609,25 +1621,16 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
      * Calculates the tap star rating of the beatmap and stores it in this instance.
      */
     calculateTap() {
-        const tapSkill = new DroidTap(this.mods, this.stats.od);
-        this.calculateSkills(tapSkill);
-        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.tap = this.attributes.tapDifficulty = 0;
-            this.attributes.possibleThreeFingeredSections = [];
-        }
-        else {
-            this.postCalculateTap(tapSkill);
-        }
-        this.calculateSpeedAttributes();
+        const od = this.stats.od;
+        const tapSkillCheese = new DroidTap(this.mods, od, true);
+        const tapSkillNoCheese = new DroidTap(this.mods, od, false);
+        this.calculateSkills(tapSkillCheese, tapSkillNoCheese);
+        this.postCalculateTap(tapSkillCheese);
     }
     /**
      * Calculates the rhythm star rating of the beatmap and stores it in this instance.
      */
     calculateRhythm() {
-        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.rhythm = this.attributes.rhythmDifficulty = 0;
-            return;
-        }
         const rhythmSkill = new DroidRhythm(this.mods, this.stats.od);
         this.calculateSkills(rhythmSkill);
         this.postCalculateRhythm(rhythmSkill);
@@ -1679,39 +1682,21 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     }
     calculateAll() {
         const skills = this.createSkills();
-        const isRelax = this.mods.some((m) => m instanceof osuBase.ModRelax);
-        if (isRelax) {
-            // Remove visual skills to reduce overhead.
-            skills.pop();
-            skills.pop();
-        }
         this.calculateSkills(...skills);
         const aimSkill = skills[0];
         const aimSkillWithoutSliders = skills[1];
         const rhythmSkill = skills[2];
-        const tapSkill = skills[3];
-        const flashlightSkill = skills[4];
-        const flashlightSkillWithoutSliders = skills[5];
-        const visualSkill = skills[6] ?? null;
-        const visualSkillWithoutSliders = skills[7] ?? null;
+        const tapSkillCheese = skills[3];
+        const flashlightSkill = skills[5];
+        const flashlightSkillWithoutSliders = skills[6];
+        const visualSkill = skills[7];
+        const visualSkillWithoutSliders = skills[8];
         this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
-        if (isRelax) {
-            this.tap = this.attributes.tapDifficulty = 0;
-        }
-        else {
-            this.postCalculateTap(tapSkill);
-        }
-        this.calculateSpeedAttributes();
-        if (!isRelax) {
-            this.postCalculateRhythm(rhythmSkill);
-        }
+        this.postCalculateTap(tapSkillCheese);
+        this.calculateTapAttributes();
+        this.postCalculateRhythm(rhythmSkill);
         this.postCalculateFlashlight(flashlightSkill, flashlightSkillWithoutSliders);
-        if (visualSkill && visualSkillWithoutSliders) {
-            this.postCalculateVisual(visualSkill, visualSkillWithoutSliders);
-        }
-        else {
-            this.visual = this.attributes.visualDifficulty = 0;
-        }
+        this.postCalculateVisual(visualSkill, visualSkillWithoutSliders);
         this.calculateTotal();
     }
     toString() {
@@ -1736,12 +1721,14 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         osuBase.HitObjectStackEvaluator.applyDroidStacking(this.beatmap.hitObjects.objects, this.beatmap.general.stackLeniency);
     }
     createSkills() {
+        const od = this.stats.od;
         return [
             new DroidAim(this.mods, true),
             new DroidAim(this.mods, false),
             // Tap skill depends on rhythm skill, so we put it first
-            new DroidRhythm(this.mods, this.stats.od),
-            new DroidTap(this.mods, this.stats.od),
+            new DroidRhythm(this.mods, od),
+            new DroidTap(this.mods, od, true),
+            new DroidTap(this.mods, od, false),
             new DroidFlashlight(this.mods, true),
             new DroidFlashlight(this.mods, false),
             new DroidVisual(this.mods, true),
@@ -1813,16 +1800,23 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     /**
      * Called after tap skill calculation.
      *
-     * @param tapSkill The tap skill.
+     * @param tapSkillCheese The tap skill that considers cheesing.
      */
-    postCalculateTap(tapSkill) {
-        this.strainPeaks.speed = tapSkill.strainPeaks;
-        this.tap = this.attributes.tapDifficulty = this.starValue(tapSkill.difficultyValue());
+    postCalculateTap(tapSkillCheese) {
+        this.strainPeaks.speed = tapSkillCheese.strainPeaks;
+        if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
+            this.tap = this.attributes.tapDifficulty = 0;
+            this.attributes.possibleThreeFingeredSections = [];
+        }
+        else {
+            this.tap = this.attributes.tapDifficulty = this.starValue(tapSkillCheese.difficultyValue());
+        }
+        this.calculateTapAttributes();
     }
     /**
-     * Calculates speed-related attributes.
+     * Calculates tap-related attributes.
      */
-    calculateSpeedAttributes() {
+    calculateTapAttributes() {
         this.attributes.possibleThreeFingeredSections = [];
         const tempSections = [];
         const objectStrains = [];
@@ -2019,7 +2013,7 @@ class PerformanceCalculator {
     calculate(options) {
         this.handleOptions(options);
         this.calculateValues();
-        this.calculateTotalValue();
+        this.total = this.calculateTotalValue();
         return this;
     }
     /**
@@ -2233,9 +2227,9 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         if (value === this._tapPenalty) {
             return;
         }
-        this.tap *= this._tapPenalty / value;
         this._tapPenalty = value;
-        this.calculateTotalValue();
+        this.tap = this.calculateTapValue();
+        this.total = this.calculateTotalValue();
     }
     /**
      * Applies an aim slider cheese penalty value to this calculator.
@@ -2255,8 +2249,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return;
         }
         this._aimSliderCheesePenalty = value;
-        this.calculateAimValue();
-        this.calculateTotalValue();
+        this.aim = this.calculateAimValue();
+        this.total = this.calculateTotalValue();
     }
     /**
      * Applies a flashlight slider cheese penalty value to this calculator.
@@ -2276,8 +2270,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return;
         }
         this._flashlightSliderCheesePenalty = value;
-        this.calculateFlashlightValue();
-        this.calculateTotalValue();
+        this.flashlight = this.calculateFlashlightValue();
+        this.total = this.calculateTotalValue();
     }
     /**
      * Applies a visual slider cheese penalty value to this calculator.
@@ -2297,25 +2291,24 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return;
         }
         this._visualSliderCheesePenalty = value;
-        this.calculateVisualValue();
-        this.calculateTotalValue();
+        this.visual = this.calculateVisualValue();
+        this.total = this.calculateTotalValue();
     }
     calculateValues() {
         this._deviation = this.calculateDeviation();
         this._tapDeviation = this.calculateTapDeviation();
-        this.calculateAimValue();
-        this.calculateTapValue();
-        this.calculateAccuracyValue();
-        this.calculateFlashlightValue();
-        this.calculateVisualValue();
+        this.aim = this.calculateAimValue();
+        this.tap = this.calculateTapValue();
+        this.accuracy = this.calculateAccuracyValue();
+        this.flashlight = this.calculateFlashlightValue();
+        this.visual = this.calculateVisualValue();
     }
     calculateTotalValue() {
-        this.total =
-            Math.pow(Math.pow(this.aim, 1.1) +
-                Math.pow(this.tap, 1.1) +
-                Math.pow(this.accuracy, 1.1) +
-                Math.pow(this.flashlight, 1.1) +
-                Math.pow(this.visual, 1.1), 1 / 1.1) * this.finalMultiplier;
+        return (Math.pow(Math.pow(this.aim, 1.1) +
+            Math.pow(this.tap, 1.1) +
+            Math.pow(this.accuracy, 1.1) +
+            Math.pow(this.flashlight, 1.1) +
+            Math.pow(this.visual, 1.1), 1 / 1.1) * this.finalMultiplier);
     }
     handleOptions(options) {
         this._tapPenalty = options?.tapPenalty ?? 1;
@@ -2330,23 +2323,31 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
      * Calculates the aim performance value of the beatmap.
      */
     calculateAimValue() {
-        this.aim = this.baseValue(Math.pow(this.difficultyAttributes.aimDifficulty, 0.8));
-        this.aim *= this.calculateMissPenalty(this.difficultyAttributes.aimDifficultStrainCount);
+        let aimValue = this.baseValue(Math.pow(this.difficultyAttributes.aimDifficulty, 0.8));
+        aimValue *= 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.
-        this.aim *= this.sliderNerfFactor;
+        aimValue *= this.sliderNerfFactor;
         // Scale the aim value with slider cheese penalty.
-        this.aim *= this._aimSliderCheesePenalty;
+        aimValue *= this._aimSliderCheesePenalty;
         // Scale the aim value with deviation.
-        this.aim *=
+        aimValue *=
             1.05 *
-                Math.pow(osuBase.ErrorFunction.erf(32.0625 / (Math.SQRT2 * this._deviation)), 1.5);
+                Math.sqrt(osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * this._deviation)));
+        // OD 7 SS stays the same.
+        aimValue *= 0.98 + Math.pow(7, 2) / 2500;
+        return aimValue;
     }
     /**
      * Calculates the tap performance value of the beatmap.
      */
     calculateTapValue() {
-        this.tap = this.baseValue(this.difficultyAttributes.tapDifficulty);
-        this.tap *= this.calculateMissPenalty(this.difficultyAttributes.tapDifficultStrainCount);
+        let tapValue = this.baseValue(this.difficultyAttributes.tapDifficulty);
+        tapValue *= this.calculateStrainBasedMissPenalty(this.difficultyAttributes.tapDifficultStrainCount);
+        // Scale the tap value with estimated full combo deviation.
+        // Require more objects to be present as object count can rack up easily in tap-oriented beatmaps.
+        tapValue *= this.calculateDeviationBasedLengthScaling(this.totalHits / 1.45);
         // Normalize the deviation to 300 BPM.
         const normalizedDeviation = this.tapDeviation *
             Math.max(1, 50 / this.difficultyAttributes.averageSpeedDeltaTime);
@@ -2360,11 +2361,14 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
                         Math.exp(-(normalizedDeviation - 7500 / averageBPM) /
                             ((2 * 300) / averageBPM))));
         // Scale the tap value with tap deviation.
-        this.tap *=
+        tapValue *=
             1.1 *
-                Math.pow(osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * adjustedDeviation)), 1.25);
+                Math.pow(osuBase.ErrorFunction.erf(20 / (Math.SQRT2 * adjustedDeviation)), 0.625);
         // Scale the tap value with three-fingered penalty.
-        this.tap /= this._tapPenalty;
+        tapValue /= this._tapPenalty;
+        // OD 8 SS stays the same.
+        tapValue *= 0.95 + Math.pow(8, 2) / 750;
+        return tapValue;
     }
     /**
      * Calculates the accuracy performance value of the beatmap.
@@ -2372,77 +2376,75 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
     calculateAccuracyValue() {
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax) ||
             this.totalSuccessfulHits === 0) {
-            this.accuracy = 0;
-            return;
+            return 0;
         }
-        this.accuracy =
-            650 *
-                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.
+        let accuracyValue = 800 * Math.exp(-0.1 * this._deviation);
         const ncircles = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModScoreV2)
             ? this.totalHits - this.difficultyAttributes.spinnerCount
             : this.difficultyAttributes.hitCircleCount;
-        this.accuracy *= Math.min(1.15, Math.sqrt(Math.log(1 + ((Math.E - 1) * ncircles) / 1000)));
+        // Bonus for many hitcircles - it's harder to keep good accuracy up for longer.
+        accuracyValue *= Math.min(1.15, Math.sqrt(Math.log(1 + ((Math.E - 1) * ncircles) / 1000)));
         // Scale the accuracy value with rhythm complexity.
-        this.accuracy *=
+        accuracyValue *=
             1.5 /
                 (1 +
                     Math.exp(-(this.difficultyAttributes.rhythmDifficulty - 1) / 2));
+        // Penalize accuracy pp after the first miss.
+        accuracyValue *= Math.pow(0.97, Math.max(0, this.effectiveMissCount - 1));
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
-            this.accuracy *= 1.02;
+            accuracyValue *= 1.02;
         }
+        return accuracyValue;
     }
     /**
      * Calculates the flashlight performance value of the beatmap.
      */
     calculateFlashlightValue() {
         if (!this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
-            this.flashlight = 0;
-            return;
+            return 0;
         }
-        this.flashlight =
-            Math.pow(this.difficultyAttributes.flashlightDifficulty, 1.6) * 25;
-        this.flashlight *= this.calculateMissPenalty(this.difficultyAttributes.flashlightDifficultStrainCount);
+        let flashlightValue = Math.pow(this.difficultyAttributes.flashlightDifficulty, 1.6) * 25;
+        flashlightValue *= this.proportionalMissPenalty;
         // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
-        this.flashlight *=
+        flashlightValue *=
             0.7 +
                 0.1 * Math.min(1, this.totalHits / 200) +
                 (this.totalHits > 200
                     ? 0.2 * Math.min(1, (this.totalHits - 200) / 200)
                     : 0);
         // Scale the flashlight value with slider cheese penalty.
-        this.flashlight *= this._flashlightSliderCheesePenalty;
+        flashlightValue *= this._flashlightSliderCheesePenalty;
         // Scale the flashlight value with deviation.
-        this.flashlight *= osuBase.ErrorFunction.erf(50 / (Math.SQRT2 * this._deviation));
+        flashlightValue *= osuBase.ErrorFunction.erf(50 / (Math.SQRT2 * this._deviation));
+        return flashlightValue;
     }
     /**
      * Calculates the visual performance value of the beatmap.
      */
     calculateVisualValue() {
-        this.visual =
-            Math.pow(this.difficultyAttributes.visualDifficulty, 1.6) * 22.5;
-        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) /
-                (1 + Math.pow(this.totalHits / 817.9306, 1.147469)));
+        let visualValue = Math.pow(this.difficultyAttributes.visualDifficulty, 1.6) * 22.5;
+        visualValue *= 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);
         // Scale the visual value with slider cheese penalty.
-        this.visual *= this._visualSliderCheesePenalty;
+        visualValue *= this._visualSliderCheesePenalty;
         // Scale the visual value with deviation.
-        this.visual *=
+        visualValue *=
             1.065 *
-                Math.pow(osuBase.ErrorFunction.erf(30 / (Math.SQRT2 * this._deviation)), 1.75);
+                Math.pow(osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * this._deviation)), 0.8);
+        // OD 5 SS stays the same.
+        visualValue *= 0.98 + Math.pow(5, 2) / 2500;
+        return visualValue;
     }
     /**
-     * Calculates miss penalty.
+     * Calculates a strain-based miss penalty.
      *
-     * Miss penalty assumes that a player will miss on the hardest parts of a map,
+     * Strain-based 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) {
+    calculateStrainBasedMissPenalty(difficultStrainCount) {
         if (this.effectiveMissCount === 0) {
             return 1;
         }
@@ -2450,6 +2452,52 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             (this.effectiveMissCount / (2 * Math.sqrt(difficultStrainCount)) +
                 1));
     }
+    /**
+     * The object-based proportional miss penalty.
+     */
+    get proportionalMissPenalty() {
+        if (this.effectiveMissCount === 0) {
+            return 1;
+        }
+        const missProportion = (this.totalHits - this.effectiveMissCount) / (this.totalHits + 1);
+        const noMissProportion = this.totalHits / (this.totalHits + 1);
+        return (
+        // Aim deviation-based scale.
+        (osuBase.ErrorFunction.erfInv(missProportion) /
+            osuBase.ErrorFunction.erfInv(noMissProportion)) *
+            // Cheesing-based scale (i.e. 50% misses is deliberately only hitting each other
+            // note, 90% misses is deliberately only hitting 1 note every 10 notes).
+            Math.pow(missProportion, 8));
+    }
+    /**
+     * Calculates the object-based length scaling based on the deviation of a player for a full
+     * combo in this beatmap, taking retries into account.
+     *
+     * @param objectCount The amount of objects to be considered. Defaults to the amount of
+     * objects in this beatmap.
+     * @param punishForMemorization Whether to punish the deviation for memorization. Defaults to `false`.
+     */
+    calculateDeviationBasedLengthScaling(objectCount = this.totalHits, punishForMemorization = false) {
+        // Assume a sample proportion of hits for a full combo to be `(n - 0.5) / n` due to
+        // continuity correction, where `n` is the object count.
+        const calculateProportion = (notes) => (notes - 0.5) / notes;
+        // Keeping `x` notes as the benchmark, assume that a player will retry a beatmap
+        // `max(1, x/n)` times relative to an `x`-note beatmap.
+        const benchmarkNotes = 700;
+        // Calculate the proportion equivalent to the bottom half of retry count percentile of
+        // scores and take it as the player's "real" proportion.
+        const retryProportion = (proportion, notes, tries) => proportion +
+            Math.sqrt((2 * proportion * (1 - proportion)) / notes) *
+                osuBase.ErrorFunction.erfInv(1 / tries - 1);
+        // Using the proportion, we calculate the deviation based off that proportion and again
+        // compared to the hit deviation for proportion `(n - 0.5) / n`.
+        let multiplier = Math.max(0, osuBase.ErrorFunction.erfInv(retryProportion(calculateProportion(objectCount), objectCount, Math.max(1, benchmarkNotes / objectCount))) / osuBase.ErrorFunction.erfInv(calculateProportion(benchmarkNotes)) || 0);
+        // Punish for memorization if needed.
+        if (punishForMemorization) {
+            multiplier *= Math.min(1, Math.sqrt(objectCount / benchmarkNotes));
+        }
+        return multiplier;
+    }
     /**
      * 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.
@@ -2470,60 +2518,60 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         }
         const hitWindow300 = new osuBase.OsuHitWindow(this.difficultyAttributes.overallDifficulty).hitWindowFor300();
         // 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 droidHitWindow = new osuBase.DroidHitWindow(osuBase.DroidHitWindow.hitWindow300ToOD(hitWindow300 * this.difficultyAttributes.clockRate, isPrecise));
         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.
-        const greatProbabilityCircle = Math.max(0, greatCountOnCircles / (this.difficultyAttributes.hitCircleCount + 1));
-        let greatProbabilitySlider;
-        if (greatCountOnCircles < 0) {
-            const nonCircleMisses = -greatCountOnCircles;
-            greatProbabilitySlider = Math.max(0, (this.difficultyAttributes.sliderCount - nonCircleMisses) /
-                (this.difficultyAttributes.sliderCount + 1));
-        }
-        else {
-            greatProbabilitySlider =
-                this.difficultyAttributes.sliderCount /
-                    (this.difficultyAttributes.sliderCount + 1);
-        }
-        if (greatProbabilityCircle === 0 && greatProbabilitySlider === 0) {
-            return Number.POSITIVE_INFINITY;
-        }
-        const calculateDeviation = (mainHitWindow, probability) => {
-            if (probability === 0) {
-                return Number.POSITIVE_INFINITY;
-            }
-            // Start with normal deviation.
-            const normalDeviation = mainHitWindow /
-                (Math.SQRT2 * osuBase.ErrorFunction.erfInv(probability));
+        const { n100, n50, nmiss } = this.computedAccuracy;
+        const circleCount = this.difficultyAttributes.hitCircleCount;
+        const missCountCircles = Math.min(nmiss, circleCount);
+        const mehCountCircles = Math.min(n50, circleCount - missCountCircles);
+        const okCountCircles = Math.min(n100, circleCount - missCountCircles - mehCountCircles);
+        const greatCountCircles = Math.max(0, circleCount - missCountCircles - mehCountCircles - okCountCircles);
+        // Assume 100s, 50s, and misses happen on circles. If there are less non-300s on circles than 300s,
+        // compute the deviation on circles.
+        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));
+            // Compute the deviation assuming 300s and 100s are normally distributed, and 50s are uniformly distributed.
+            // Begin with the normal distribution first.
+            const deviationOnCircles = hitWindow300 /
+                (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbabilityCircle));
             // Get the variance of the truncated variable.
-            const truncatedVariance = Math.pow(normalDeviation, 2) -
-                (Math.SQRT2 *
+            const truncatedVariance = Math.pow(deviationOnCircles, 2) -
+                (Math.sqrt(2 / Math.PI) *
                     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);
+                    deviationOnCircles *
+                    Math.exp(-0.5 * Math.pow(hitWindow100 / deviationOnCircles, 2))) /
+                    osuBase.ErrorFunction.erf(hitWindow100 / (Math.SQRT2 * deviationOnCircles));
+            // Then compute the variance for 50s.
+            const mehVariance = (Math.pow(hitWindow50, 2) +
+                hitWindow100 * hitWindow50 +
+                Math.pow(hitWindow100, 2)) /
+                3;
+            // Find the total deviation.
+            return Math.sqrt(((greatCountCircles + okCountCircles) * truncatedVariance +
+                mehCountCircles * mehVariance) /
+                (greatCountCircles + okCountCircles + mehCountCircles));
+        }
+        // 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
+        // to get a 100 or 50 on a slider by mis-tapping it.
+        const sliderCount = this.difficultyAttributes.sliderCount;
+        const missCountSliders = Math.min(sliderCount, nmiss - missCountCircles);
+        const greatCountSliders = sliderCount - missCountSliders;
+        // We only get here if nothing was hit. In this case, there is no estimate for deviation.
+        // Note that this is never negative, so checking if this is only equal to 0 makes sense.
+        if (greatCountSliders === 0) {
+            return Number.POSITIVE_INFINITY;
+        }
+        const greatProbabilitySlider = greatCountSliders / (sliderCount + 1);
+        return (hitWindow50 /
+            (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbabilitySlider)));
     }
     /**
      * Does the same as {@link calculateDeviation}, but only for notes and inaccuracies that are relevant to tap difficulty.
@@ -2536,15 +2584,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return Number.POSITIVE_INFINITY;
         }
         const hitWindow300 = new osuBase.OsuHitWindow(this.difficultyAttributes.overallDifficulty).hitWindowFor300();
-        // 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;
+        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;
@@ -2559,25 +2599,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             return Number.POSITIVE_INFINITY;
         }
         const greatProbability = relevantCountGreat / (this.difficultyAttributes.speedNoteCount + 1);
-        // 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));
+        return (hitWindow300 / (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbability)));
     }
     toString() {
         return (this.total.toFixed(2) +
@@ -2764,36 +2786,37 @@ class OsuAimEvaluator extends AimEvaluator {
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 class OsuAim extends OsuSkill {
-    skillMultiplier = 23.55;
     strainDecayBase = 0.15;
     reducedSectionCount = 10;
     reducedSectionBaseline = 0.75;
-    difficultyMultiplier = 1.06;
     decayWeight = 0.9;
+    currentAimStrain = 0;
+    skillMultiplier = 23.55;
     withSliders;
     constructor(mods, withSliders) {
         super(mods);
         this.withSliders = withSliders;
     }
-    /**
-     * @param current The hitobject to calculate.
-     */
     strainValueAt(current) {
-        this.currentStrain *= this.strainDecay(current.deltaTime);
-        this.currentStrain +=
+        this.currentAimStrain *= this.strainDecay(current.deltaTime);
+        this.currentAimStrain +=
             OsuAimEvaluator.evaluateDifficultyOf(current, this.withSliders) *
                 this.skillMultiplier;
-        return this.currentStrain;
+        return this.currentAimStrain;
+    }
+    calculateInitialStrain(time, current) {
+        return (this.currentAimStrain *
+            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
     }
     /**
      * @param current The hitobject to save to.
      */
     saveToHitObject(current) {
         if (this.withSliders) {
-            current.aimStrainWithSliders = this.currentStrain;
+            current.aimStrainWithSliders = this.currentAimStrain;
         }
         else {
-            current.aimStrainWithoutSliders = this.currentStrain;
+            current.aimStrainWithoutSliders = this.currentAimStrain;
         }
     }
 }
@@ -2965,7 +2988,6 @@ class OsuRhythmEvaluator extends RhythmEvaluator {
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
 class OsuSpeed extends OsuSkill {
-    skillMultiplier = 1375;
     strainDecayBase = 0.3;
     reducedSectionCount = 5;
     reducedSectionBaseline = 0.75;
@@ -2973,6 +2995,7 @@ class OsuSpeed extends OsuSkill {
     decayWeight = 0.9;
     currentSpeedStrain = 0;
     currentRhythm = 0;
+    skillMultiplier = 1375;
     greatWindow;
     constructor(mods, greatWindow) {
         super(mods);
@@ -2989,11 +3012,16 @@ class OsuSpeed extends OsuSkill {
         this.currentRhythm = OsuRhythmEvaluator.evaluateDifficultyOf(current, this.greatWindow);
         return this.currentSpeedStrain * this.currentRhythm;
     }
+    calculateInitialStrain(time, current) {
+        return (this.currentSpeedStrain *
+            this.currentRhythm *
+            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
+    }
     /**
      * @param current The hitobject to save to.
      */
     saveToHitObject(current) {
-        current.tapStrain = this.currentStrain;
+        current.tapStrain = this.currentSpeedStrain * this.currentRhythm;
         current.rhythmMultiplier = this.currentRhythm;
     }
 }
@@ -3084,27 +3112,29 @@ class OsuFlashlightEvaluator extends FlashlightEvaluator {
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 class OsuFlashlight extends OsuSkill {
-    skillMultiplier = 0.052;
     strainDecayBase = 0.15;
     reducedSectionCount = 0;
     reducedSectionBaseline = 1;
     decayWeight = 1;
+    currentFlashlightStrain = 0;
+    skillMultiplier = 0.052;
     isHidden;
     constructor(mods) {
         super(mods);
         this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
     }
-    /**
-     * @param current The hitobject to calculate.
-     */
     strainValueAt(current) {
-        this.currentStrain *= this.strainDecay(current.deltaTime);
-        this.currentStrain +=
+        this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
+        this.currentFlashlightStrain +=
             OsuFlashlightEvaluator.evaluateDifficultyOf(current, this.isHidden) * this.skillMultiplier;
-        return this.currentStrain;
+        return this.currentFlashlightStrain;
+    }
+    calculateInitialStrain(time, current) {
+        return (this.currentFlashlightStrain *
+            this.strainDecay(time - (current.previous(0)?.startTime ?? 0)));
     }
     saveToHitObject(current) {
-        current.flashlightStrainWithSliders = this.currentStrain;
+        current.flashlightStrainWithSliders = this.currentFlashlightStrain;
     }
 }
 
@@ -3367,6 +3397,18 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
     difficultyAttributes;
     finalMultiplier = 1.14;
     mode = osuBase.Modes.osu;
+    calculateValues() {
+        this.aim = this.calculateAimValue();
+        this.speed = this.calculateSpeedValue();
+        this.accuracy = this.calculateAccuracyValue();
+        this.flashlight = this.calculateFlashlightValue();
+    }
+    calculateTotalValue() {
+        return (Math.pow(Math.pow(this.aim, 1.1) +
+            Math.pow(this.speed, 1.1) +
+            Math.pow(this.accuracy, 1.1) +
+            Math.pow(this.flashlight, 1.1), 1 / 1.1) * this.finalMultiplier);
+    }
     /**
      * @param difficultyAttributes The difficulty attributes to calculate.
      */
@@ -3374,39 +3416,27 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         super();
         this.difficultyAttributes = osuBase.Utils.deepCopy(difficultyAttributes);
     }
-    calculateValues() {
-        this.calculateAimValue();
-        this.calculateSpeedValue();
-        this.calculateAccuracyValue();
-        this.calculateFlashlightValue();
-    }
-    calculateTotalValue() {
-        this.total =
-            Math.pow(Math.pow(this.aim, 1.1) +
-                Math.pow(this.speed, 1.1) +
-                Math.pow(this.accuracy, 1.1) +
-                Math.pow(this.flashlight, 1.1), 1 / 1.1) * this.finalMultiplier;
-    }
     /**
      * Calculates the aim performance value of the beatmap.
      */
     calculateAimValue() {
-        this.aim = this.baseValue(this.difficultyAttributes.aimDifficulty);
+        let aimValue = this.baseValue(this.difficultyAttributes.aimDifficulty);
         // Longer maps are worth more
         let lengthBonus = 0.95 + 0.4 * Math.min(1, this.totalHits / 2000);
         if (this.totalHits > 2000) {
             lengthBonus += Math.log10(this.totalHits / 2000) * 0.5;
         }
-        this.aim *= lengthBonus;
+        aimValue *= lengthBonus;
         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 *=
+            // Penalize misses by assessing # of misses relative to the total # of objects.
+            // Default a 3% reduction for any # of misses.
+            aimValue *=
                 0.97 *
                     Math.pow(1 -
                         Math.pow(this.effectiveMissCount / this.totalHits, 0.775), this.effectiveMissCount);
         }
         // Combo scaling
-        this.aim *= this.comboPenalty;
+        aimValue *= this.comboPenalty;
         const calculatedAR = this.difficultyAttributes.approachRate;
         if (!this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
             // AR scaling
@@ -3418,66 +3448,70 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
                 arFactor += 0.05 * (8 - calculatedAR);
             }
             // Buff for longer maps with high AR.
-            this.aim *= 1 + arFactor * lengthBonus;
+            aimValue *= 1 + arFactor * lengthBonus;
         }
         // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHidden)) {
-            this.aim *= 1 + 0.04 * (12 - calculatedAR);
+            aimValue *= 1 + 0.04 * (12 - calculatedAR);
         }
         // Scale the aim value with slider factor to nerf very likely dropped sliderends.
-        this.aim *= this.sliderNerfFactor;
+        aimValue *= this.sliderNerfFactor;
         // Scale the aim value with accuracy.
-        this.aim *= this.computedAccuracy.value();
+        aimValue *= 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;
+        aimValue *= 0.98 + odScaling;
+        return aimValue;
     }
     /**
      * Calculates the speed performance value of the beatmap.
      */
     calculateSpeedValue() {
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.speed = 0;
-            return;
+            return 0;
         }
-        // Global variables
-        this.speed = this.baseValue(this.difficultyAttributes.speedDifficulty);
+        let speedValue = this.baseValue(this.difficultyAttributes.speedDifficulty);
         // Longer maps are worth more
         let lengthBonus = 0.95 + 0.4 * Math.min(1, this.totalHits / 2000);
         if (this.totalHits > 2000) {
             lengthBonus += Math.log10(this.totalHits / 2000) * 0.5;
         }
-        this.speed *= lengthBonus;
+        speedValue *= lengthBonus;
         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.speed *=
+            // Penalize misses by assessing # of misses relative to the total # of objects.
+            // Default a 3% reduction for any # of misses.
+            speedValue *=
                 0.97 *
                     Math.pow(1 -
                         Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
         }
         // Combo scaling
-        this.speed *= this.comboPenalty;
+        speedValue *= this.comboPenalty;
         // AR scaling
         const calculatedAR = this.difficultyAttributes.approachRate;
         if (calculatedAR > 10.33) {
             // Buff for longer maps with high AR.
-            this.speed *= 1 + 0.3 * (calculatedAR - 10.33) * lengthBonus;
+            speedValue *= 1 + 0.3 * (calculatedAR - 10.33) * lengthBonus;
         }
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHidden)) {
-            this.speed *= 1 + 0.04 * (12 - calculatedAR);
+            speedValue *= 1 + 0.04 * (12 - calculatedAR);
         }
         // Calculate accuracy assuming the worst case scenario.
         const countGreat = this.computedAccuracy.n300;
         const countOk = this.computedAccuracy.n100;
         const countMeh = this.computedAccuracy.n50;
         const relevantTotalDiff = this.totalHits - this.difficultyAttributes.speedNoteCount;
-        const relevantAccuracy = new osuBase.Accuracy({
-            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)),
-        });
+        const relevantAccuracy = new osuBase.Accuracy(this.difficultyAttributes.speedNoteCount > 0
+            ? {
+                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)),
+            }
+            : // Set accuracy to 0.
+                { n300: 0, nobjects: 1 });
         // Scale the speed value with accuracy and OD.
-        this.speed *=
+        speedValue *=
             (0.95 +
                 Math.pow(this.difficultyAttributes.overallDifficulty, 2) /
                     750) *
@@ -3487,22 +3521,21 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
                     Math.max(this.difficultyAttributes.overallDifficulty, 8)) /
                     2);
         // Scale the speed value with # of 50s to punish doubletapping.
-        this.speed *= Math.pow(0.99, Math.max(0, this.computedAccuracy.n50 - this.totalHits / 500));
+        speedValue *= Math.pow(0.99, Math.max(0, this.computedAccuracy.n50 - this.totalHits / 500));
+        return speedValue;
     }
     /**
      * Calculates the accuracy performance value of the beatmap.
      */
     calculateAccuracyValue() {
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModRelax)) {
-            this.accuracy = 0;
-            return;
+            return 0;
         }
         const ncircles = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModScoreV2)
             ? this.totalHits - this.difficultyAttributes.spinnerCount
             : this.difficultyAttributes.hitCircleCount;
         if (ncircles === 0) {
-            this.accuracy = 0;
-            return;
+            return 0;
         }
         const realAccuracy = new osuBase.Accuracy({
             ...this.computedAccuracy,
@@ -3510,52 +3543,50 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
         });
         // Lots of arbitrary values from testing.
         // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
-        this.accuracy =
-            Math.pow(1.52163, this.difficultyAttributes.overallDifficulty) *
-                // 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;
+        let accuracyValue = Math.pow(1.52163, this.difficultyAttributes.overallDifficulty) *
+            // 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));
+        accuracyValue *= Math.min(1.15, Math.pow(ncircles / 1000, 0.3));
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHidden)) {
-            this.accuracy *= 1.08;
+            accuracyValue *= 1.08;
         }
         if (this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
-            this.accuracy *= 1.02;
+            accuracyValue *= 1.02;
         }
+        return accuracyValue;
     }
     /**
      * Calculates the flashlight performance value of the beatmap.
      */
     calculateFlashlightValue() {
         if (!this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModFlashlight)) {
-            this.flashlight = 0;
-            return;
+            return 0;
         }
-        // Global variables
-        this.flashlight =
-            Math.pow(this.difficultyAttributes.flashlightDifficulty, 2) * 25;
+        let flashlightValue = Math.pow(this.difficultyAttributes.flashlightDifficulty, 2) * 25;
         // Combo scaling
-        this.flashlight *= this.comboPenalty;
+        flashlightValue *= 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 *=
+            flashlightValue *=
                 0.97 *
                     Math.pow(1 -
                         Math.pow(this.effectiveMissCount / this.totalHits, 0.775), Math.pow(this.effectiveMissCount, 0.875));
         }
         // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
-        this.flashlight *=
+        flashlightValue *=
             0.7 +
                 0.1 * Math.min(1, this.totalHits / 200) +
                 (this.totalHits > 200
                     ? 0.2 * Math.min(1, (this.totalHits - 200) / 200)
                     : 0);
         // Scale the flashlight value with accuracy slightly.
-        this.flashlight *= 0.5 + this.computedAccuracy.value() / 2;
+        flashlightValue *= 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;
+        flashlightValue *= 0.98 + odScaling;
+        return flashlightValue;
     }
     toString() {
         return (this.total.toFixed(2) +