@rian8337/osu-difficulty-calculator 4.0.0-beta.76 → 4.0.0-beta.78

package/dist/index.js

@@ -249,12 +249,8 @@ class DifficultyHitObject {
      * Computes the properties of this hitobject.
      *
      * @param clockRate The clock rate of the beatmap.
-     * @param hitObjects The hitobjects in the beatmap.
      */
-    computeProperties(clockRate, 
-    // Required for `DroidDifficultyHitObject` override.
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    hitObjects) {
+    computeProperties(clockRate) {
         this.calculateSliderCursorPosition();
         this.setDistances(clockRate);
     }
@@ -348,7 +344,11 @@ class DifficultyHitObject {
             return;
         }
         // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
-        const { scalingFactor } = this;
+        let scalingFactor = DifficultyHitObject.normalizedRadius / this.object.radius;
+        // High circle size (small CS) bonus
+        if (this.mode === osuBase.Modes.osu && this.object.radius < 30) {
+            scalingFactor *= 1 + Math.min(30 - this.object.radius, 5) / 50;
+        }
         const lastCursorPosition = this.lastDifficultyObject !== null
             ? this.getEndCursorPosition(this.lastDifficultyObject)
             : this.lastObject.stackedPosition;
@@ -503,16 +503,8 @@ DifficultyHitObject.minDeltaTime = 25;
  * Represents an osu!droid hit object with difficulty calculation values.
  */
 class DroidDifficultyHitObject extends DifficultyHitObject {
-    get scalingFactor() {
-        const radius = this.object.radius;
-        // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
-        let scalingFactor = DifficultyHitObject.normalizedRadius / radius;
-        // High circle size (small CS) bonus
-        if (radius < this.radiusBuffThreshold) {
-            scalingFactor *=
-                1 + Math.pow((this.radiusBuffThreshold - radius) / 50, 2);
-        }
-        return scalingFactor;
+    get smallCircleBonus() {
+        return Math.max(1, 1 + Math.pow((70 - this.object.radius) / 50, 2));
     }
     /**
      * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
@@ -547,13 +539,9 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
          */
         this.flashlightStrainWithoutSliders = 0;
         /**
-         * The visual strain generated by the hitobject if sliders are considered.
-         */
-        this.visualStrainWithSliders = 0;
-        /**
-         * The visual strain generated by the hitobject if sliders are not considered.
+         * The reading difficulty generated by the hitobject.
          */
-        this.visualStrainWithoutSliders = 0;
+        this.readingDifficulty = 0;
         /**
          * The note density of the hitobject.
          */
@@ -569,10 +557,6 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
         this.maximumSliderRadius = DifficultyHitObject.normalizedRadius * 2;
         this.timePreempt = object.timePreempt / clockRate;
     }
-    computeProperties(clockRate, hitObjects) {
-        super.computeProperties(clockRate, hitObjects);
-        this.setVisuals(clockRate, hitObjects);
-    }
     opacityAt(time, mods) {
         // Traceable hides the primary piece of a hit circle (that is, its body), so consider it as fully invisible.
         if (this.object instanceof osuBase.Circle && mods.has(osuBase.ModTraceable)) {
@@ -649,60 +633,6 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
         }
         return true;
     }
-    setVisuals(clockRate, hitObjects) {
-        // We'll have two visible object arrays. The first array contains objects before the current object starts in a reversed order,
-        // while the second array contains objects after the current object ends.
-        // For overlapping factor, we also need to consider previous visible objects.
-        const prevVisibleObjects = [];
-        const nextVisibleObjects = [];
-        for (let j = this.index + 2; j < hitObjects.length; ++j) {
-            const o = hitObjects[j];
-            if (o instanceof osuBase.Spinner) {
-                continue;
-            }
-            if (o.startTime / clockRate > this.endTime + this.timePreempt) {
-                break;
-            }
-            nextVisibleObjects.push(o);
-        }
-        for (let j = 0; j < this.index; ++j) {
-            const prev = this.previous(j);
-            if (prev.object instanceof osuBase.Spinner) {
-                continue;
-            }
-            if (prev.startTime >= this.startTime) {
-                continue;
-            }
-            if (prev.startTime < this.startTime - this.timePreempt) {
-                break;
-            }
-            prevVisibleObjects.push(prev.object);
-        }
-        for (const hitObject of prevVisibleObjects) {
-            const distance = this.object.stackedPosition.getDistance(hitObject.stackedEndPosition);
-            const deltaTime = this.startTime - hitObject.endTime / clockRate;
-            this.applyToOverlappingFactor(distance, deltaTime);
-        }
-        for (const hitObject of nextVisibleObjects) {
-            const distance = hitObject.stackedPosition.getDistance(this.object.stackedEndPosition);
-            const deltaTime = hitObject.startTime / clockRate - this.endTime;
-            if (deltaTime >= 0) {
-                this.noteDensity += 1 - deltaTime / this.timePreempt;
-            }
-            this.applyToOverlappingFactor(distance, deltaTime);
-        }
-    }
-    applyToOverlappingFactor(distance, deltaTime) {
-        // Penalize objects that are too close to the object in both distance
-        // and delta time to prevent stream maps from being overweighted.
-        this.overlappingFactor +=
-            Math.max(0, 1 - distance / (2.5 * this.object.radius)) *
-                (7.5 /
-                    (1 +
-                        Math.exp(0.15 *
-                            (Math.max(deltaTime, DifficultyHitObject.minDeltaTime) -
-                                75))));
-    }
 }
 
 /**
@@ -740,6 +670,7 @@ class DroidAimEvaluator {
         }
         const last = current.previous(0);
         const lastLast = current.previous(1);
+        const last2 = current.previous(2);
         const radius = DroidDifficultyHitObject.normalizedRadius;
         const diameter = DroidDifficultyHitObject.normalizedDiameter;
         // Calculate the velocity to the current hitobject, which starts with a base distance / time assuming the last object is a hitcircle.
@@ -771,36 +702,35 @@ class DroidAimEvaluator {
         let wiggleBonus = 0;
         // Start strain with regular velocity.
         let strain = currentVelocity;
-        if (
-        // If rhythms are the same.
-        Math.max(current.strainTime, last.strainTime) <
-            1.25 * Math.min(current.strainTime, last.strainTime) &&
-            current.angle !== null &&
-            last.angle !== null) {
+        if (current.angle !== null && last.angle !== null) {
             const currentAngle = current.angle;
             const lastAngle = last.angle;
             // Rewarding angles, take the smaller velocity as base.
             const angleBonus = Math.min(currentVelocity, prevVelocity);
+            // If rhythms are the same.
+            if (Math.max(current.strainTime, last.strainTime) <
+                1.25 * Math.min(current.strainTime, last.strainTime)) {
+                acuteAngleBonus = this.calculateAcuteAngleBonus(current.angle);
+                acuteAngleBonus *=
+                    0.08 +
+                        0.92 *
+                            (1 -
+                                Math.min(acuteAngleBonus, Math.pow(this.calculateAcuteAngleBonus(lastAngle), 3)));
+                // Apply acute angle bonus for BPM above 300 1/2 and distance more than 1.25 diameter
+                acuteAngleBonus *=
+                    angleBonus *
+                        osuBase.MathUtils.smootherstep(osuBase.MathUtils.millisecondsToBPM(current.strainTime, 2), 300, 450) *
+                        osuBase.MathUtils.smootherstep(current.lazyJumpDistance, diameter * 1.25, diameter * 2.5);
+            }
             wideAngleBonus = this.calculateWideAngleBonus(current.angle);
-            acuteAngleBonus = this.calculateAcuteAngleBonus(current.angle);
             // Penalize angle repetition.
             wideAngleBonus *=
                 1 -
                     Math.min(wideAngleBonus, Math.pow(this.calculateWideAngleBonus(lastAngle), 3));
-            acuteAngleBonus *=
-                0.08 +
-                    0.92 *
-                        (1 -
-                            Math.min(acuteAngleBonus, Math.pow(this.calculateAcuteAngleBonus(lastAngle), 3)));
             // Apply full wide angle bonus for distance more than one diameter
             wideAngleBonus *=
                 angleBonus *
                     osuBase.MathUtils.smootherstep(current.lazyJumpDistance, 0, diameter);
-            // Apply acute angle bonus for BPM above 300 1/2 and distance more than one diameter
-            acuteAngleBonus *=
-                angleBonus *
-                    osuBase.MathUtils.smootherstep(osuBase.MathUtils.millisecondsToBPM(current.strainTime, 2), 300, 400) *
-                    osuBase.MathUtils.smootherstep(current.lazyJumpDistance, diameter, diameter * 2);
             // Apply wiggle bonus for jumps that are [radius, 3*diameter] in distance, with < 110 angle
             // https://www.desmos.com/calculator/dp0v0nvowc
             wiggleBonus =
@@ -811,6 +741,15 @@ class DroidAimEvaluator {
                     osuBase.MathUtils.smootherstep(last.lazyJumpDistance, radius, diameter) *
                     Math.pow(osuBase.MathUtils.reverseLerp(last.lazyJumpDistance, diameter * 3, diameter), 1.8) *
                     osuBase.MathUtils.smootherstep(lastAngle, osuBase.MathUtils.degreesToRadians(110), osuBase.MathUtils.degreesToRadians(60));
+            if (last2 !== null) {
+                // If objects just go back and forth through a middle point - don't give as much wide bonus.
+                // Use previous(2) and previous(0) because angles calculation is done prevprev-prev-curr, so any
+                // object's angle's center point is always the previous object.
+                const distance = last2.object.stackedPosition.getDistance(last.object.stackedPosition);
+                if (distance < 1) {
+                    wideAngleBonus *= 1 - 0.35 * (1 - distance);
+                }
+            }
         }
         if (Math.max(prevVelocity, currentVelocity)) {
             // We want to use the average velocity over the whole object when awarding differences, not the individual jump and slider path velocities.
@@ -821,8 +760,8 @@ class DroidAimEvaluator {
                 (current.lazyJumpDistance + last.travelDistance) /
                     current.strainTime;
             // Scale with ratio of difference compared to half the max distance.
-            const distanceRatio = Math.pow(Math.sin(((Math.PI / 2) * Math.abs(prevVelocity - currentVelocity)) /
-                Math.max(prevVelocity, currentVelocity)), 2);
+            const distanceRatio = osuBase.MathUtils.smoothstep(Math.abs(prevVelocity - currentVelocity) /
+                Math.max(prevVelocity, currentVelocity), 0, 1);
             // Reward for % distance up to 125 / strainTime for overlaps where velocity is still changing.
             const overlapVelocityBuff = Math.min(125 / Math.min(current.strainTime, last.strainTime), Math.abs(prevVelocity - currentVelocity));
             velocityChangeBonus = overlapVelocityBuff * distanceRatio;
@@ -835,9 +774,11 @@ class DroidAimEvaluator {
             sliderBonus = last.travelDistance / last.travelTime;
         }
         strain += wiggleBonus * this.wiggleMultiplier;
-        // Add in acute angle bonus or wide angle bonus + velocity change bonus, whichever is larger.
-        strain += Math.max(acuteAngleBonus * this.acuteAngleMultiplier, wideAngleBonus * this.wideAngleMultiplier +
-            velocityChangeBonus * this.velocityChangeMultiplier);
+        strain += velocityChangeBonus * this.velocityChangeMultiplier;
+        // Add in acute angle bonus or wide angle bonus, whichever is larger.
+        strain += Math.max(acuteAngleBonus * this.acuteAngleMultiplier, wideAngleBonus * this.wideAngleMultiplier);
+        // Apply high circle size bonus
+        strain *= current.smallCircleBonus;
         // Add in additional slider velocity bonus.
         if (withSliders) {
             strain +=
@@ -861,7 +802,12 @@ class DroidAimEvaluator {
         const travelDistance = (_a = prev === null || prev === void 0 ? void 0 : prev.travelDistance) !== null && _a !== void 0 ? _a : 0;
         const distance = travelDistance + current.minimumJumpDistance;
         const shortDistancePenalty = Math.min(1, Math.pow(distance / this.singleSpacingThreshold, 3.5));
-        return (200 * speedBonus * shortDistancePenalty) / current.strainTime;
+        return ((200 *
+            speedBonus *
+            shortDistancePenalty *
+            // Apply reduced small circle bonus for flow aim difficulty since it does not scale as hard as snap aim.
+            Math.sqrt(current.smallCircleBonus)) /
+            current.strainTime);
     }
     static calculateWideAngleBonus(angle) {
         return osuBase.MathUtils.smoothstep(angle, osuBase.MathUtils.degreesToRadians(40), osuBase.MathUtils.degreesToRadians(140));
@@ -870,8 +816,8 @@ class DroidAimEvaluator {
         return osuBase.MathUtils.smoothstep(angle, osuBase.MathUtils.degreesToRadians(140), osuBase.MathUtils.degreesToRadians(40));
     }
 }
-DroidAimEvaluator.wideAngleMultiplier = 1.5;
-DroidAimEvaluator.acuteAngleMultiplier = 2.6;
+DroidAimEvaluator.wideAngleMultiplier = 1.6;
+DroidAimEvaluator.acuteAngleMultiplier = 2.4;
 DroidAimEvaluator.sliderMultiplier = 1.35;
 DroidAimEvaluator.velocityChangeMultiplier = 0.75;
 DroidAimEvaluator.wiggleMultiplier = 1.02;
@@ -944,7 +890,7 @@ class StrainSkill extends Skill {
      *
      * The result is scaled by clock rate as it affects the total number of strains.
      */
-    countDifficultStrains() {
+    countTopWeightedStrains() {
         if (this.difficulty === 0) {
             return 0;
         }
@@ -1034,21 +980,18 @@ class DroidAim extends DroidSkill {
         this.skillMultiplier = 26.5;
         this.currentAimStrain = 0;
         this.sliderStrains = [];
+        this.maxSliderStrain = 0;
         this.withSliders = withSliders;
     }
     /**
      * Obtains the amount of sliders that are considered difficult in terms of relative strain.
      */
     countDifficultSliders() {
-        if (this.sliderStrains.length === 0) {
-            return 0;
-        }
-        const maxSliderStrain = osuBase.MathUtils.max(this.sliderStrains);
-        if (maxSliderStrain === 0) {
+        if (this.sliderStrains.length === 0 || this.maxSliderStrain === 0) {
             return 0;
         }
         return this.sliderStrains.reduce((total, strain) => total +
-            1 / (1 + Math.exp(-((strain / maxSliderStrain) * 12 - 6))), 0);
+            1 / (1 + Math.exp(-((strain / this.maxSliderStrain) * 12 - 6))), 0);
     }
     strainValueAt(current) {
         this.currentAimStrain *= this.strainDecay(current.deltaTime);
@@ -1057,6 +1000,7 @@ class DroidAim extends DroidSkill {
                 this.skillMultiplier;
         if (current.object instanceof osuBase.Slider) {
             this.sliderStrains.push(this.currentAimStrain);
+            this.maxSliderStrain = Math.max(this.maxSliderStrain, this.currentAimStrain);
         }
         return this.currentAimStrain;
     }
@@ -1089,10 +1033,10 @@ class DroidDifficultyAttributes extends DifficultyAttributes {
         super(cacheableAttributes);
         this.tapDifficulty = 0;
         this.rhythmDifficulty = 0;
-        this.visualDifficulty = 0;
+        this.readingDifficulty = 0;
         this.tapDifficultStrainCount = 0;
         this.flashlightDifficultStrainCount = 0;
-        this.visualDifficultStrainCount = 0;
+        this.readingDifficultNoteCount = 0;
         this.averageSpeedDeltaTime = 0;
         this.vibroFactor = 1;
         if (!cacheableAttributes) {
@@ -1100,13 +1044,13 @@ class DroidDifficultyAttributes extends DifficultyAttributes {
         }
         this.tapDifficulty = cacheableAttributes.tapDifficulty;
         this.rhythmDifficulty = cacheableAttributes.rhythmDifficulty;
-        this.visualDifficulty = cacheableAttributes.visualDifficulty;
+        this.readingDifficulty = cacheableAttributes.readingDifficulty;
         this.tapDifficultStrainCount =
             cacheableAttributes.tapDifficultStrainCount;
         this.flashlightDifficultStrainCount =
             cacheableAttributes.flashlightDifficultStrainCount;
-        this.visualDifficultStrainCount =
-            cacheableAttributes.visualDifficultStrainCount;
+        this.readingDifficultNoteCount =
+            cacheableAttributes.readingDifficultNoteCount;
         this.averageSpeedDeltaTime = cacheableAttributes.averageSpeedDeltaTime;
         this.vibroFactor = cacheableAttributes.vibroFactor;
     }
@@ -1116,7 +1060,7 @@ class DroidDifficultyAttributes extends DifficultyAttributes {
             `${this.tapDifficulty.toFixed(2)} tap, ` +
             `${this.rhythmDifficulty.toFixed(2)} rhythm, ` +
             `${this.flashlightDifficulty.toFixed(2)} flashlight, ` +
-            `${this.visualDifficulty.toFixed(2)} visual)`);
+            `${this.readingDifficulty.toFixed(2)} reading)`);
     }
 }
 
@@ -1265,6 +1209,312 @@ class DroidFlashlight extends DroidSkill {
     }
 }
 
+/**
+ * An evaluator for calculating osu!droid reading skill.
+ */
+class DroidReadingEvaluator {
+    static evaluateDifficultyOf(current, clockRate, mods) {
+        if (current.object instanceof osuBase.Spinner ||
+            // Exclude overlapping objects that can be tapped at once.
+            current.isOverlapping(true) ||
+            current.index <= 0) {
+            return 0;
+        }
+        const constantAngleNerfFactor = this.getConstantAngleNerfFactor(current);
+        // Only allow velocity to buff.
+        const velocityFactor = Math.max(1, current.minimumJumpDistance / current.strainTime);
+        let pastObjectDifficultyInfluence = 0;
+        for (const prev of this.retrievePastVisibleObjects(current)) {
+            let prevDifficulty = current.opacityAt(prev.object.startTime, this.emptyModMap);
+            // Small distances mean objects may be cheesed, so it does not matter whether they are arranged confusingly.
+            prevDifficulty *= osuBase.MathUtils.smootherstep(prev.lazyJumpDistance, 15, this.distanceInfluenceThreshold);
+            // Account less for objects close to the maximum reading window.
+            prevDifficulty *= this.getTimeNerfFactor(current.startTime - prev.startTime);
+            pastObjectDifficultyInfluence += prevDifficulty;
+        }
+        // Value higher note densities exponentially.
+        let noteDensityDifficulty = Math.pow(pastObjectDifficultyInfluence, 1.45) *
+            0.9 *
+            constantAngleNerfFactor *
+            velocityFactor;
+        // Award only denser than average beatmaps.
+        noteDensityDifficulty = Math.max(0, noteDensityDifficulty - this.densityDifficultyBase);
+        // Apply a soft cap to general density reading to account for partial memorization.
+        noteDensityDifficulty =
+            Math.pow(noteDensityDifficulty, 0.8) * this.densityMultiplier;
+        let hiddenDifficulty = 0;
+        if (mods.has(osuBase.ModHidden)) {
+            const timeSpentInvisible = this.getDurationSpentInvisible(current) / clockRate;
+            // Value time spent invisible exponentially.
+            const timeSpentInvisibleFactor = Math.pow(timeSpentInvisible, 2.1) * 0.0001;
+            // Buff current object if upcoming objects are dense. This is on the basis that part of
+            // Hidden difficulty is the uncertainty of the current cursor position in relation to
+            // future notes.
+            const futureObjectDifficultyInfluence = this.calculateCurrentVisibleObjectsDensity(current);
+            // Account for both past and current densities.
+            const densityFactor = Math.pow(Math.max(1, futureObjectDifficultyInfluence +
+                pastObjectDifficultyInfluence -
+                2), 2.2) * 3.1;
+            hiddenDifficulty +=
+                (timeSpentInvisibleFactor + densityFactor) *
+                    constantAngleNerfFactor *
+                    velocityFactor *
+                    0.007;
+            // Apply a soft cap to general Hidden reading to account for partial memorization.
+            hiddenDifficulty =
+                Math.pow(hiddenDifficulty, 0.65) * this.hiddenMultiplier;
+            const prev = current.previous(0);
+            // Buff perfect stacks only if the current object is completely invisible at the
+            // time the previous object was clicked.
+            if (current.lazyJumpDistance === 0 &&
+                current.opacityAt(prev.object.startTime + prev.object.timePreempt, mods) === 0 &&
+                prev.startTime + prev.timePreempt > current.startTime) {
+                hiddenDifficulty +=
+                    (this.hiddenMultiplier * 1303) /
+                        // Perfect stacks are harder the less time between notes.
+                        Math.pow(current.strainTime, 1.5);
+            }
+        }
+        // Arbitrary curve for the base value preempt difficulty should have as approach rate increases.
+        // https://www.desmos.com/calculator/9v2wrms1ie
+        const preemptDifficulty = (Math.pow((this.preemptStartingPoint -
+            current.timePreempt +
+            Math.abs(current.timePreempt - this.preemptStartingPoint)) /
+            2, 2.35) /
+            this.preemptBalancingFactor) *
+            constantAngleNerfFactor *
+            velocityFactor;
+        let sliderDifficulty = 0;
+        if (current.object instanceof osuBase.Slider) {
+            const scalingFactor = 50 / current.object.radius;
+            // Invert the scaling factor to determine the true travel distance independent of circle size.
+            const pixelTravelDistance = current.lazyTravelDistance / scalingFactor;
+            const currentVelocity = pixelTravelDistance / current.travelTime;
+            const spanTravelDistance = pixelTravelDistance / current.object.spanCount;
+            sliderDifficulty +=
+                // Reward sliders based on velocity, while also avoiding overbuffing extremely fast sliders.
+                Math.min(4, currentVelocity * 0.8) *
+                    // Longer sliders require more reading.
+                    (spanTravelDistance / 125);
+            let cumulativeStrainTime = 0;
+            // Reward for velocity changes based on last few sliders.
+            for (let i = 0; i < Math.min(current.index, 4); ++i) {
+                const last = current.previous(i);
+                cumulativeStrainTime += last.strainTime;
+                if (!(last.object instanceof osuBase.Slider) ||
+                    // Exclude overlapping objects that can be tapped at once.
+                    last.isOverlapping(true)) {
+                    continue;
+                }
+                // Invert the scaling factor to determine the true travel distance independent of circle size.
+                const lastPixelTravelDistance = last.lazyTravelDistance / scalingFactor;
+                const lastVelocity = lastPixelTravelDistance / last.travelTime;
+                const lastSpanTravelDistance = lastPixelTravelDistance / last.object.spanCount;
+                sliderDifficulty +=
+                    // Reward past sliders based on velocity changes, while also
+                    // avoiding overbuffing extremely fast velocity changes.
+                    Math.min(4, 0.8 * Math.abs(currentVelocity - lastVelocity)) *
+                        // Longer sliders require more reading.
+                        (lastSpanTravelDistance / 150) *
+                        // Avoid overbuffing past sliders.
+                        Math.min(1, 250 / cumulativeStrainTime);
+            }
+        }
+        return (preemptDifficulty +
+            hiddenDifficulty +
+            noteDensityDifficulty +
+            sliderDifficulty);
+    }
+    /**
+     * Retrieves a list of objects that are visible at the point in time the current object needs to be hit.
+     *
+     * @param current The current object.
+     */
+    static *retrievePastVisibleObjects(current) {
+        for (let i = 0; i < current.index; ++i) {
+            const prev = current.previous(i);
+            if (!prev ||
+                current.startTime - prev.startTime > this.readingWindowSize ||
+                // The previous object is not visible at the time the current object needs to be hit.
+                prev.startTime + prev.timePreempt < current.startTime) {
+                break;
+            }
+            if (prev.isOverlapping(true)) {
+                continue;
+            }
+            yield prev;
+        }
+    }
+    /**
+     * Calculates the density of objects visible at the point in time the current object needs to be hit.
+     *
+     * @param current The current object.
+     */
+    static calculateCurrentVisibleObjectsDensity(current) {
+        let visibleObjectCount = 0;
+        let index = 0;
+        let next = current.next(0);
+        while (next) {
+            if (next.startTime - current.startTime > this.readingWindowSize ||
+                // The next object is not visible at the time the current object needs to be hit.
+                current.startTime + current.timePreempt < next.startTime) {
+                break;
+            }
+            if (next.isOverlapping(true)) {
+                continue;
+            }
+            const timeNerfFactor = this.getTimeNerfFactor(next.startTime - current.startTime);
+            visibleObjectCount +=
+                next.opacityAt(current.object.startTime, this.emptyModMap) *
+                    timeNerfFactor;
+            next = current.next(++index);
+        }
+        return visibleObjectCount;
+    }
+    /**
+     * Returns the time an object spends invisible with the Hidden mod at the current approach rate.
+     *
+     * @param current The current object.
+     */
+    static getDurationSpentInvisible(current) {
+        const { object } = current;
+        const fadeOutStartTime = object.startTime - object.timePreempt + object.timeFadeIn;
+        const fadeOutDuration = object.timePreempt * osuBase.ModHidden.fadeOutDurationMultiplier;
+        return (fadeOutStartTime +
+            fadeOutDuration -
+            (object.startTime - object.timePreempt));
+    }
+    /**
+     * Calculates a factor of how often the current object's angle has been repeated in a certain time frame.
+     * It does this by checking the difference in angle between current and past objects and sums them up
+     * based on a range of similarity.
+     *
+     * @param current The current object.
+     */
+    static getConstantAngleNerfFactor(current) {
+        const maxTimeLimit = 2000; // 2 seconds
+        const minTimeLimit = 200;
+        let constantAngleCount = 0;
+        let index = 0;
+        let currentTimeGap = 0;
+        while (currentTimeGap < maxTimeLimit) {
+            const loopObj = current.previous(index);
+            if (!loopObj) {
+                break;
+            }
+            if (loopObj.angle !== null && current.angle !== null) {
+                const angleDifference = Math.abs(current.angle - loopObj.angle);
+                // Account less for objects that are close to the time limit.
+                const longIntervalFactor = osuBase.MathUtils.clamp(1 -
+                    (loopObj.strainTime - minTimeLimit) /
+                        (maxTimeLimit - minTimeLimit), 0, 1);
+                constantAngleCount +=
+                    Math.cos(3 * Math.min(Math.PI / 6, angleDifference)) *
+                        longIntervalFactor;
+            }
+            currentTimeGap = current.startTime - loopObj.startTime;
+            index++;
+        }
+        return osuBase.MathUtils.clamp(2 / constantAngleCount, 0.2, 1);
+    }
+    static getTimeNerfFactor(deltaTime) {
+        return osuBase.MathUtils.clamp(2 - deltaTime / (this.readingWindowSize / 2), 0, 1);
+    }
+}
+DroidReadingEvaluator.emptyModMap = new osuBase.ModMap();
+DroidReadingEvaluator.readingWindowSize = 3000; // 3 seconds
+DroidReadingEvaluator.distanceInfluenceThreshold = DroidDifficultyHitObject.normalizedDiameter * 1.25; // 1.25 circles distance between centers
+DroidReadingEvaluator.hiddenMultiplier = 0.85;
+DroidReadingEvaluator.densityMultiplier = 0.8;
+DroidReadingEvaluator.densityDifficultyBase = 1.5;
+DroidReadingEvaluator.preemptBalancingFactor = 220000;
+DroidReadingEvaluator.preemptStartingPoint = 475; // AR 9.83 in milliseconds
+
+/**
+ * Represents the skill required to read every object in the map.
+ */
+class DroidReading extends Skill {
+    constructor(mods, clockRate, hitObjects) {
+        super(mods);
+        this.clockRate = clockRate;
+        this.hitObjects = hitObjects;
+        this.noteDifficulties = [];
+        this.strainDecayBase = 0.8;
+        this.skillMultiplier = 2;
+        this.currentNoteDifficulty = 0;
+        this.difficulty = 0;
+        this.noteWeightSum = 0;
+    }
+    process(current) {
+        this.currentNoteDifficulty *= this.strainDecay(current.deltaTime);
+        this.currentNoteDifficulty +=
+            DroidReadingEvaluator.evaluateDifficultyOf(current, this.clockRate, this.mods) * this.skillMultiplier;
+        const difficulty = this.currentNoteDifficulty * current.rhythmMultiplier;
+        this.noteDifficulties.push(difficulty);
+        current.readingDifficulty = difficulty;
+    }
+    difficultyValue() {
+        if (this.hitObjects.length === 0) {
+            return 0;
+        }
+        // Notes with 0 difficulty are excluded to avoid worst-case time complexity of the following sort (e.g. /b/2351871).
+        // These notes will not contribute to the difficulty.
+        const peaks = this.noteDifficulties.filter((d) => d > 0);
+        // Start time at first object.
+        const reducedDuration = this.hitObjects[0].startTime / this.clockRate + 60 * 1000;
+        // Assume the first few seconds are completely memorized.
+        let reducedCount = 0;
+        for (const object of this.hitObjects) {
+            if (object.startTime / this.clockRate > reducedDuration) {
+                break;
+            }
+            ++reducedCount;
+        }
+        for (let i = 0; i < Math.min(peaks.length, reducedCount); ++i) {
+            peaks[i] *= Math.log10(osuBase.Interpolation.lerp(1, 10, osuBase.MathUtils.clamp(i / reducedCount, 0, 1)));
+        }
+        peaks.sort((a, b) => b - a);
+        // Difficulty is the weighted sum of the highest notes.
+        // We're sorting from highest to lowest note.
+        this.difficulty = 0;
+        this.noteWeightSum = 0;
+        for (let i = 0; i < peaks.length; ++i) {
+            // Use a harmonic sum for note which effectively buffs maps with more notes, especially if
+            // note difficulties are consistent. Constants are arbitrary and give good values.
+            // https://www.desmos.com/calculator/5eb60faf4c
+            const weight = (1 + 1 / (1 + i)) / (Math.pow(i, 0.8) + 1 + 1 / (1 + i));
+            if (weight === 0) {
+                // Shortcut to avoid unnecessary iterations.
+                break;
+            }
+            this.noteWeightSum += weight;
+            this.difficulty += peaks[i] * weight;
+        }
+        return this.difficulty;
+    }
+    /**
+     * Returns the number of relevant objects weighted against the top note.
+     */
+    countTopWeightedNotes() {
+        if (this.noteDifficulties.length === 0 ||
+            this.difficulty === 0 ||
+            this.noteWeightSum === 0) {
+            return 0;
+        }
+        // What would the top note be if all note values were identical
+        const consistentTopNote = this.difficulty / this.noteWeightSum;
+        if (consistentTopNote === 0) {
+            return 0;
+        }
+        // Use a weighted sum of all notes. Constants are arbitrary and give nice values
+        return this.noteDifficulties.reduce((total, next) => total +
+            1.1 / (1 + Math.exp(-5 * (next / consistentTopNote - 1.15))), 0);
+    }
+    strainDecay(ms) {
+        return Math.pow(this.strainDecayBase, ms / 1000);
+    }
+}
+
 class Island {
     constructor(delta, deltaDifferenceEpsilon) {
         this.delta = Number.MAX_SAFE_INTEGER;
@@ -1346,21 +1596,23 @@ class DroidRhythmEvaluator {
             const noteDecay = (validPrevious.length - i) / validPrevious.length;
             // Either we're limited by time or limited by object count.
             const currentHistoricalDecay = Math.min(timeDecay, noteDecay);
-            const currentDelta = currentObject.strainTime;
-            const prevDelta = prevObject.strainTime;
-            const lastDelta = lastObject.strainTime;
-            // Calculate how much current delta difference deserves a rhythm bonus
-            // This function is meant to reduce rhythm bonus for deltas that are multiples of each other (i.e. 100 and 200)
-            const deltaDifferenceRatio = Math.min(prevDelta, currentDelta) /
-                Math.max(prevDelta, currentDelta);
+            // Use custom cap value to ensure that that at this point delta time is actually zero.
+            const currentDelta = Math.max(currentObject.deltaTime, 1e-7);
+            const prevDelta = Math.max(prevObject.deltaTime, 1e-7);
+            const lastDelta = Math.max(lastObject.deltaTime, 1e-7);
+            // Calculate how much current delta difference deserves a rhythm bonus.
+            // This function is meant to reduce rhythm bonus for deltas that are multiples of each other (i.e. 100 and 200).
+            const deltaDifference = Math.max(prevDelta, currentDelta) /
+                Math.min(prevDelta, currentDelta);
+            // Take only the fractional part of the value since we are only interested in punishing multiples.
+            const deltaDifferenceFraction = deltaDifference - Math.trunc(deltaDifference);
             const currentRatio = 1 +
                 this.rhythmRatioMultiplier *
-                    Math.min(0.5, Math.pow(Math.sin(Math.PI / deltaDifferenceRatio), 2));
+                    Math.min(0.5, osuBase.MathUtils.smoothstepBellCurve(deltaDifferenceFraction));
             // Reduce ratio bonus if delta difference is too big
-            const fraction = Math.max(prevDelta / currentDelta, currentDelta / prevDelta);
-            const fractionMultiplier = osuBase.MathUtils.clamp(2 - fraction / 8, 0, 1);
+            const differenceMultiplier = osuBase.MathUtils.clamp(2 - deltaDifference / 8, 0, 1);
             const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) - deltaDifferenceEpsilon) / deltaDifferenceEpsilon);
-            let effectiveRatio = windowPenalty * currentRatio * fractionMultiplier;
+            let effectiveRatio = windowPenalty * currentRatio * differenceMultiplier;
             if (firstDeltaSwitch) {
                 if (Math.abs(prevDelta - currentDelta) < deltaDifferenceEpsilon) {
                     // Island is still progressing, count size.
@@ -1454,7 +1706,7 @@ class DroidRhythmEvaluator {
 DroidRhythmEvaluator.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
 DroidRhythmEvaluator.historyObjectsMax = 32;
 DroidRhythmEvaluator.rhythmOverallMultiplier = 0.95;
-DroidRhythmEvaluator.rhythmRatioMultiplier = 12;
+DroidRhythmEvaluator.rhythmRatioMultiplier = 15;
 
 /**
  * Represents the skill required to properly follow a beatmap's rhythm.
@@ -1471,10 +1723,11 @@ class DroidRhythm extends DroidSkill {
         this.useSliderAccuracy = mods.has(osuBase.ModScoreV2);
     }
     strainValueAt(current) {
-        this.currentRhythmMultiplier =
-            DroidRhythmEvaluator.evaluateDifficultyOf(current, this.useSliderAccuracy);
+        const rhythmMultiplier = DroidRhythmEvaluator.evaluateDifficultyOf(current, this.useSliderAccuracy);
+        const doubletapness = 1 - current.doubletapness;
         this.currentRhythmStrain *= this.strainDecay(current.deltaTime);
-        this.currentRhythmStrain += this.currentRhythmMultiplier - 1;
+        this.currentRhythmStrain += (rhythmMultiplier - 1) * doubletapness;
+        this.currentRhythmMultiplier = rhythmMultiplier * doubletapness;
         return this.currentRhythmStrain;
     }
     calculateInitialStrain(time, current) {
@@ -1552,6 +1805,7 @@ class DroidTap extends DroidSkill {
         this.currentRhythmMultiplier = 0;
         this.skillMultiplier = 1.375;
         this._objectDeltaTimes = [];
+        this.maxStrain = 0;
         this.considerCheesability = considerCheesability;
         this.strainTimeCap = strainTimeCap;
     }
@@ -1559,33 +1813,27 @@ class DroidTap extends DroidSkill {
      * The amount of notes that are relevant to the difficulty.
      */
     relevantNoteCount() {
-        if (this._objectStrains.length === 0) {
-            return 0;
-        }
-        const maxStrain = osuBase.MathUtils.max(this._objectStrains);
-        if (maxStrain === 0) {
+        if (this._objectStrains.length === 0 || this.maxStrain === 0) {
             return 0;
         }
-        return this._objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
+        return this._objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / this.maxStrain) * 12 - 6))), 0);
     }
     /**
      * The delta time relevant to the difficulty.
      */
     relevantDeltaTime() {
-        if (this._objectStrains.length === 0) {
-            return 0;
-        }
-        const maxStrain = osuBase.MathUtils.max(this._objectStrains);
-        if (maxStrain === 0) {
+        if (this._objectStrains.length === 0 || this.maxStrain === 0) {
             return 0;
         }
         return (this._objectDeltaTimes.reduce((total, next, index) => total +
-            (next * 1) /
+            next /
                 (1 +
-                    Math.exp(-((this._objectStrains[index] / maxStrain) *
+                    Math.exp(-((this._objectStrains[index] /
+                        this.maxStrain) *
                         25 -
                         20))), 0) /
-            this._objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 25 - 20))), 0));
+            this._objectStrains.reduce((total, next) => total +
+                1 / (1 + Math.exp(-((next / this.maxStrain) * 25 - 20))), 0));
     }
     strainValueAt(current) {
         this.currentTapStrain *= this.strainDecay(current.strainTime);
@@ -1593,7 +1841,9 @@ class DroidTap extends DroidSkill {
             DroidTapEvaluator.evaluateDifficultyOf(current, this.considerCheesability, this.strainTimeCap) * this.skillMultiplier;
         this.currentRhythmMultiplier = current.rhythmMultiplier;
         this._objectDeltaTimes.push(current.deltaTime);
-        return this.currentTapStrain * current.rhythmMultiplier;
+        const strain = this.currentTapStrain * this.currentRhythmMultiplier;
+        this.maxStrain = Math.max(this.maxStrain, strain);
+        return strain;
     }
     calculateInitialStrain(time, current) {
         var _a, _b;
@@ -1621,153 +1871,6 @@ class DroidTap extends DroidSkill {
     }
 }
 
-/**
- * An evaluator for calculating osu!droid visual skill.
- */
-class DroidVisualEvaluator {
-    /**
-     * Evaluates the difficulty of reading the current object, based on:
-     *
-     * - note density of the current object,
-     * - overlapping factor of the current object,
-     * - the preempt time of the current object,
-     * - the visual opacity of the current object,
-     * - the velocity of the current object if it's a slider,
-     * - past objects' velocity if they are sliders,
-     * - and whether the Hidden mod is enabled.
-     *
-     * @param current The current object.
-     * @param mods The mods used.
-     * @param withSliders Whether to take slider difficulty into account.
-     */
-    static evaluateDifficultyOf(current, mods, withSliders) {
-        if (current.object instanceof osuBase.Spinner ||
-            // Exclude overlapping objects that can be tapped at once.
-            current.isOverlapping(true) ||
-            current.index === 0) {
-            return 0;
-        }
-        // Start with base density and give global bonus for Hidden.
-        // Add density caps for sanity.
-        let strain;
-        if (mods.has(osuBase.ModHidden)) {
-            strain = Math.min(30, Math.pow(current.noteDensity, 3));
-        }
-        else if (mods.has(osuBase.ModTraceable)) {
-            // Give more bonus for hit circles due to there being no circle piece.
-            if (current.object instanceof osuBase.Circle) {
-                strain = Math.min(25, Math.pow(current.noteDensity, 2.5));
-            }
-            else {
-                strain = Math.min(22.5, Math.pow(current.noteDensity, 2.25));
-            }
-        }
-        else {
-            strain = Math.min(20, Math.pow(current.noteDensity, 2));
-        }
-        // Bonus based on how visible the object is.
-        for (let i = 0; i < Math.min(current.index, 10); ++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;
-            }
-            // Do not consider objects that don't fall under time preempt.
-            if (current.object.startTime - previous.object.endTime >
-                current.object.timePreempt) {
-                break;
-            }
-            strain +=
-                (1 - current.opacityAt(previous.object.startTime, mods)) / 4;
-        }
-        if (current.timePreempt < 400) {
-            // Give bonus for AR higher than 10.33.
-            strain += Math.pow(400 - current.timePreempt, 1.35) / 100;
-        }
-        // Scale the value with overlapping factor.
-        strain /= 10 * (1 + current.overlappingFactor);
-        if (current.object instanceof osuBase.Slider && withSliders) {
-            const scalingFactor = 50 / current.object.radius;
-            // Invert the scaling factor to determine the true travel distance independent of circle size.
-            const pixelTravelDistance = current.lazyTravelDistance / scalingFactor;
-            const currentVelocity = pixelTravelDistance / current.travelTime;
-            const spanTravelDistance = pixelTravelDistance / current.object.spanCount;
-            strain +=
-                // Reward sliders based on velocity, while also avoiding overbuffing extremely fast sliders.
-                Math.min(6, currentVelocity * 1.5) *
-                    // Longer sliders require more reading.
-                    (spanTravelDistance / 100);
-            let cumulativeStrainTime = 0;
-            // Reward for velocity changes based on last few sliders.
-            for (let i = 0; i < Math.min(current.index, 4); ++i) {
-                const last = current.previous(i);
-                cumulativeStrainTime += last.strainTime;
-                if (!(last.object instanceof osuBase.Slider) ||
-                    // Exclude overlapping objects that can be tapped at once.
-                    last.isOverlapping(true)) {
-                    continue;
-                }
-                // Invert the scaling factor to determine the true travel distance independent of circle size.
-                const lastPixelTravelDistance = last.lazyTravelDistance / scalingFactor;
-                const lastVelocity = lastPixelTravelDistance / last.travelTime;
-                const lastSpanTravelDistance = lastPixelTravelDistance / last.object.spanCount;
-                strain +=
-                    // Reward past sliders based on velocity changes, while also
-                    // avoiding overbuffing extremely fast velocity changes.
-                    Math.min(10, 2.5 * Math.abs(currentVelocity - lastVelocity)) *
-                        // Longer sliders require more reading.
-                        (lastSpanTravelDistance / 125) *
-                        // Avoid overbuffing past sliders.
-                        Math.min(1, 300 / cumulativeStrainTime);
-            }
-        }
-        return strain;
-    }
-}
-
-/**
- * Represents the skill required to read every object in the map.
- */
-class DroidVisual extends DroidSkill {
-    constructor(mods, withSliders) {
-        super(mods);
-        this.starsPerDouble = 1.025;
-        this.reducedSectionCount = 10;
-        this.reducedSectionBaseline = 0.75;
-        this.strainDecayBase = 0.1;
-        this.currentVisualStrain = 0;
-        this.currentRhythmMultiplier = 1;
-        this.skillMultiplier = 11.2;
-        this.withSliders = withSliders;
-    }
-    strainValueAt(current) {
-        this.currentVisualStrain *= this.strainDecay(current.deltaTime);
-        this.currentVisualStrain +=
-            DroidVisualEvaluator.evaluateDifficultyOf(current, this.mods, this.withSliders) * this.skillMultiplier;
-        this.currentRhythmMultiplier = current.rhythmMultiplier;
-        return this.currentVisualStrain * this.currentRhythmMultiplier;
-    }
-    calculateInitialStrain(time, current) {
-        var _a, _b;
-        return (this.currentVisualStrain *
-            this.currentRhythmMultiplier *
-            this.strainDecay(time - ((_b = (_a = current.previous(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : 0)));
-    }
-    getObjectStrain() {
-        return this.currentVisualStrain * this.currentRhythmMultiplier;
-    }
-    saveToHitObject(current) {
-        const strain = this.currentVisualStrain * this.currentRhythmMultiplier;
-        if (this.withSliders) {
-            current.visualStrainWithSliders = strain;
-        }
-        else {
-            current.visualStrainWithoutSliders = strain;
-        }
-    }
-}
-
 /**
  * Holds data that can be used to calculate osu!droid performance points as well
  * as doing some analysis using the replay of a score.
@@ -1778,19 +1881,15 @@ class ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes {
         this.mode = "live";
         this.possibleThreeFingeredSections = [];
         this.difficultSliders = [];
-        this.aimNoteCount = 0;
         this.flashlightSliderFactor = 1;
-        this.visualSliderFactor = 1;
         if (!cacheableAttributes) {
             return;
         }
         this.possibleThreeFingeredSections =
             cacheableAttributes.possibleThreeFingeredSections;
         this.difficultSliders = cacheableAttributes.difficultSliders;
-        this.aimNoteCount = cacheableAttributes.aimNoteCount;
         this.flashlightSliderFactor =
             cacheableAttributes.flashlightSliderFactor;
-        this.visualSliderFactor = cacheableAttributes.visualSliderFactor;
     }
 }
 
@@ -1816,31 +1915,28 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         attributes.hitCircleCount = beatmap.hitObjects.circles;
         attributes.sliderCount = beatmap.hitObjects.sliders;
         attributes.spinnerCount = beatmap.hitObjects.spinners;
+        let greatWindow;
+        if (attributes.mods.has(osuBase.ModPrecise)) {
+            greatWindow = new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od)
+                .greatWindow;
+        }
+        else {
+            greatWindow = new osuBase.DroidHitWindow(beatmap.difficulty.od).greatWindow;
+        }
+        attributes.overallDifficulty = osuBase.OsuHitWindow.greatWindowToOD(greatWindow / attributes.clockRate);
         this.populateAimAttributes(attributes, skills, objects);
         this.populateTapAttributes(attributes, skills, objects);
         this.populateRhythmAttributes(attributes, skills);
         this.populateFlashlightAttributes(attributes, skills);
-        this.populateVisualAttributes(attributes, skills);
-        if (beatmap.mods.has(osuBase.ModRelax)) {
-            attributes.aimDifficulty *= 0.9;
-            attributes.tapDifficulty = 0;
-            attributes.rhythmDifficulty = 0;
-            attributes.flashlightDifficulty *= 0.7;
-            attributes.visualDifficulty = 0;
-        }
-        else if (beatmap.mods.has(osuBase.ModAutopilot)) {
-            attributes.aimDifficulty = 0;
-            attributes.flashlightDifficulty *= 0.3;
-            attributes.visualDifficulty *= 0.8;
-        }
+        this.populateReadingAttributes(attributes, skills);
         const aimPerformanceValue = this.basePerformanceValue(Math.pow(attributes.aimDifficulty, 0.8));
         const tapPerformanceValue = this.basePerformanceValue(attributes.tapDifficulty);
         const flashlightPerformanceValue = Math.pow(attributes.flashlightDifficulty, 1.6) * 25;
-        const visualPerformanceValue = Math.pow(attributes.visualDifficulty, 1.6) * 22.5;
+        const readingPerformanceValue = Math.pow(Math.pow(attributes.readingDifficulty, 2) * 25, 0.8);
         const basePerformanceValue = Math.pow(Math.pow(aimPerformanceValue, 1.1) +
             Math.pow(tapPerformanceValue, 1.1) +
             Math.pow(flashlightPerformanceValue, 1.1) +
-            Math.pow(visualPerformanceValue, 1.1), 1 / 1.1);
+            Math.pow(readingPerformanceValue, 1.1), 1 / 1.1);
         if (basePerformanceValue > 1e-5) {
             // Document for formula derivation:
             // https://docs.google.com/document/d/10DZGYYSsT_yjz2Mtp6yIJld0Rqx4E-vVHupCqiM4TNI/edit
@@ -1852,15 +1948,6 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         else {
             attributes.starRating = 0;
         }
-        let greatWindow;
-        if (attributes.mods.has(osuBase.ModPrecise)) {
-            greatWindow = new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od)
-                .greatWindow;
-        }
-        else {
-            greatWindow = new osuBase.DroidHitWindow(beatmap.difficulty.od).greatWindow;
-        }
-        attributes.overallDifficulty = osuBase.OsuHitWindow.greatWindowToOD(greatWindow / attributes.clockRate);
         return attributes;
     }
     createPlayableBeatmap(beatmap, mods) {
@@ -1873,7 +1960,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         const { objects } = beatmap.hitObjects;
         for (let i = 0; i < objects.length; ++i) {
             const difficultyObject = new DroidDifficultyHitObject(objects[i], (_a = objects[i - 1]) !== null && _a !== void 0 ? _a : null, difficultyObjects, clockRate, i - 1);
-            difficultyObject.computeProperties(clockRate, objects);
+            difficultyObject.computeProperties(clockRate);
             difficultyObjects.push(difficultyObject);
         }
         return difficultyObjects;
@@ -1886,13 +1973,13 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             skills.push(new DroidAim(mods, false));
         }
         if (!mods.has(osuBase.ModRelax)) {
-            // Tap and visual skills depend on rhythm skill, so we put it first
+            // Tap skills depend on rhythm skill, so we put it first
             skills.push(new DroidRhythm(mods));
             skills.push(new DroidTap(mods, true));
             skills.push(new DroidTap(mods, false));
-            skills.push(new DroidVisual(mods, true));
-            skills.push(new DroidVisual(mods, false));
+            skills.push(new DroidTap(mods, true, 50));
         }
+        skills.push(new DroidReading(mods, beatmap.speedMultiplier, beatmap.hitObjects.objects));
         if (mods.has(osuBase.ModFlashlight)) {
             skills.push(new DroidFlashlight(mods, true));
             skills.push(new DroidFlashlight(mods, false));
@@ -1911,12 +1998,18 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     populateAimAttributes(attributes, skills, objects) {
         const aim = skills.find((s) => s instanceof DroidAim && s.withSliders);
         const aimNoSlider = skills.find((s) => s instanceof DroidAim && !s.withSliders);
-        if (!aim || !aimNoSlider) {
+        if (!aim || !aimNoSlider || attributes.mods.has(osuBase.ModAutopilot)) {
+            attributes.aimDifficulty = 0;
+            attributes.aimDifficultSliderCount = 0;
+            attributes.aimDifficultStrainCount = 0;
             return;
         }
         attributes.aimDifficulty = this.calculateRating(aim);
         attributes.aimDifficultSliderCount = aim.countDifficultSliders();
-        attributes.aimDifficultStrainCount = aim.countDifficultStrains();
+        attributes.aimDifficultStrainCount = aim.countTopWeightedStrains();
+        if (attributes.mods.has(osuBase.ModRelax)) {
+            attributes.aimDifficulty *= 0.9;
+        }
         const topDifficultSliders = [];
         for (let i = 0; i < objects.length; ++i) {
             const object = objects[i];
@@ -1955,18 +2048,22 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     }
     populateTapAttributes(attributes, skills, objects) {
         const tap = skills.find((s) => s instanceof DroidTap && s.considerCheesability);
-        if (!tap) {
+        const tapVibro = skills.find((s) => s instanceof DroidTap &&
+            s.considerCheesability &&
+            s.strainTimeCap !== undefined);
+        if (!tap || !tapVibro || attributes.mods.has(osuBase.ModRelax)) {
+            attributes.tapDifficulty = 0;
+            attributes.tapDifficultStrainCount = 0;
+            attributes.speedNoteCount = 0;
+            attributes.averageSpeedDeltaTime = 0;
+            attributes.vibroFactor = 1;
             return;
         }
         attributes.tapDifficulty = this.calculateRating(tap);
-        attributes.tapDifficultStrainCount = tap.countDifficultStrains();
+        attributes.tapDifficultStrainCount = tap.countTopWeightedStrains();
         attributes.speedNoteCount = tap.relevantNoteCount();
         attributes.averageSpeedDeltaTime = tap.relevantDeltaTime();
         if (attributes.tapDifficulty > 0) {
-            const tapVibro = new DroidTap(attributes.mods, true, attributes.averageSpeedDeltaTime);
-            for (const object of objects) {
-                tapVibro.process(object);
-            }
             attributes.vibroFactor =
                 this.calculateRating(tapVibro) / attributes.tapDifficulty;
         }
@@ -2013,20 +2110,29 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
     }
     populateRhythmAttributes(attributes, skills) {
         const rhythm = skills.find((s) => s instanceof DroidRhythm);
-        if (!rhythm) {
-            return;
-        }
-        attributes.rhythmDifficulty = this.calculateRating(rhythm);
+        attributes.rhythmDifficulty =
+            rhythm && !attributes.mods.has(osuBase.ModRelax)
+                ? this.calculateRating(rhythm)
+                : 0;
     }
     populateFlashlightAttributes(attributes, skills) {
         const flashlight = skills.find((s) => s instanceof DroidFlashlight && s.withSliders);
         const flashlightNoSliders = skills.find((s) => s instanceof DroidFlashlight && !s.withSliders);
         if (!flashlight || !flashlightNoSliders) {
+            attributes.flashlightDifficulty = 0;
+            attributes.flashlightDifficultStrainCount = 0;
+            attributes.flashlightSliderFactor = 1;
             return;
         }
         attributes.flashlightDifficulty = this.calculateRating(flashlight);
         attributes.flashlightDifficultStrainCount =
-            flashlight.countDifficultStrains();
+            flashlight.countTopWeightedStrains();
+        if (attributes.mods.has(osuBase.ModRelax)) {
+            attributes.flashlightDifficulty *= 0.7;
+        }
+        else if (attributes.mods.has(osuBase.ModAutopilot)) {
+            attributes.flashlightDifficulty *= 0.4;
+        }
         if (attributes.flashlightDifficulty > 0) {
             attributes.flashlightSliderFactor =
                 this.calculateRating(flashlightNoSliders) /
@@ -2036,22 +2142,25 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
             attributes.flashlightSliderFactor = 1;
         }
     }
-    populateVisualAttributes(attributes, skills) {
-        const visual = skills.find((s) => s instanceof DroidVisual && s.withSliders);
-        const visualNoSliders = skills.find((s) => s instanceof DroidVisual && !s.withSliders);
-        if (!visual || !visualNoSliders) {
+    populateReadingAttributes(attributes, skills) {
+        const reading = skills.find((s) => s instanceof DroidReading);
+        if (!reading) {
+            attributes.readingDifficulty = 0;
+            attributes.readingDifficultNoteCount = 0;
             return;
         }
-        attributes.visualDifficulty = this.calculateRating(visual);
-        attributes.visualDifficultStrainCount = visual.countDifficultStrains();
-        if (attributes.visualDifficulty > 0) {
-            attributes.visualSliderFactor =
-                this.calculateRating(visualNoSliders) /
-                    attributes.visualDifficulty;
+        attributes.readingDifficulty = this.calculateRating(reading);
+        attributes.readingDifficultNoteCount = reading.countTopWeightedNotes();
+        if (attributes.mods.has(osuBase.ModRelax)) {
+            attributes.readingDifficulty *= 0.7;
         }
-        else {
-            attributes.visualSliderFactor = 1;
+        else if (attributes.mods.has(osuBase.ModAutopilot)) {
+            attributes.readingDifficulty *= 0.4;
         }
+        // Consider accuracy difficulty.
+        const ratingMultiplier = 0.75 +
+            Math.pow(Math.max(0, attributes.overallDifficulty), 2.2) / 800;
+        attributes.readingDifficulty *= Math.sqrt(ratingMultiplier);
     }
 }
 /**
@@ -2322,14 +2431,13 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
          */
         this.flashlight = 0;
         /**
-         * The visual performance value.
+         * The reading performance value.
          */
-        this.visual = 0;
+        this.reading = 0;
         this.finalMultiplier = 1.24;
         this.mode = osuBase.Modes.droid;
         this._aimSliderCheesePenalty = 1;
         this._flashlightSliderCheesePenalty = 1;
-        this._visualSliderCheesePenalty = 1;
         this._tapPenalty = 1;
         this._deviation = 0;
         this._tapDeviation = 0;
@@ -2370,14 +2478,6 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
     get flashlightSliderCheesePenalty() {
         return this._flashlightSliderCheesePenalty;
     }
-    /**
-     * The penalty used to penalize the visual performance value.
-     *
-     * Can be properly obtained by analyzing the replay associated with the score.
-     */
-    get visualSliderCheesePenalty() {
-        return this._visualSliderCheesePenalty;
-    }
     /**
      * Applies a tap penalty value to this calculator.
      *
@@ -2438,27 +2538,6 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         this.flashlight = this.calculateFlashlightValue();
         this.total = this.calculateTotalValue();
     }
-    /**
-     * Applies a visual slider cheese penalty value to this calculator.
-     *
-     * The visual and total performance value will be recalculated afterwards.
-     *
-     * @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 or equal to zero.");
-        }
-        if (value > 1) {
-            throw new RangeError("New visual slider cheese penalty must be less than or equal to one.");
-        }
-        if (value === this._visualSliderCheesePenalty) {
-            return;
-        }
-        this._visualSliderCheesePenalty = value;
-        this.visual = this.calculateVisualValue();
-        this.total = this.calculateTotalValue();
-    }
     calculateValues() {
         this._deviation = this.calculateDeviation();
         this._tapDeviation = this.calculateTapDeviation();
@@ -2466,23 +2545,21 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         this.tap = this.calculateTapValue();
         this.accuracy = this.calculateAccuracyValue();
         this.flashlight = this.calculateFlashlightValue();
-        this.visual = this.calculateVisualValue();
+        this.reading = this.calculateReadingValue();
     }
     calculateTotalValue() {
         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);
+            Math.pow(this.reading, 1.1), 1 / 1.1) * this.finalMultiplier);
     }
     handleOptions(options) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         this._tapPenalty = (_a = options === null || options === void 0 ? void 0 : options.tapPenalty) !== null && _a !== void 0 ? _a : 1;
         this._aimSliderCheesePenalty = (_b = options === null || options === void 0 ? void 0 : options.aimSliderCheesePenalty) !== null && _b !== void 0 ? _b : 1;
         this._flashlightSliderCheesePenalty =
             (_c = options === null || options === void 0 ? void 0 : options.flashlightSliderCheesePenalty) !== null && _c !== void 0 ? _c : 1;
-        this._visualSliderCheesePenalty =
-            (_d = options === null || options === void 0 ? void 0 : options.visualSliderCheesePenalty) !== null && _d !== void 0 ? _d : 1;
         super.handleOptions(options);
     }
     /**
@@ -2541,6 +2618,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
                     Math.exp((this._tapDeviation - 7500 / averageBPM) /
                         ((2 * 300) / averageBPM))) +
                 Math.pow(this.difficultyAttributes.vibroFactor, 6);
+        tapValue *= this.calculateTapHighDeviationNerf();
         // Scale the tap value with three-fingered penalty.
         tapValue /= this._tapPenalty;
         // OD 8 SS stays the same.
@@ -2595,23 +2673,20 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         return flashlightValue;
     }
     /**
-     * Calculates the visual performance value of the beatmap.
+     * Calculates the reading performance value of the beatmap.
      */
-    calculateVisualValue() {
-        let visualValue = Math.pow(this.difficultyAttributes.visualDifficulty, 1.6) * 22.5;
-        visualValue *= Math.min(this.calculateStrainBasedMissPenalty(this.difficultyAttributes.visualDifficultStrainCount), this.proportionalMissPenalty);
-        // Scale the visual value with estimated full combo deviation.
-        // As visual is easily "bypassable" with memorization, punish for memorization.
-        visualValue *= this.calculateDeviationBasedLengthScaling(undefined, true);
-        // Scale the visual value with slider cheese penalty.
-        visualValue *= this._visualSliderCheesePenalty;
-        // Scale the visual value with deviation.
-        visualValue *=
-            1.05 *
-                Math.pow(osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * this._deviation)), 0.775);
+    calculateReadingValue() {
+        let readingValue = Math.pow(Math.pow(this.difficultyAttributes.readingDifficulty, 2) * 25, 0.8);
+        readingValue *= Math.min(this.calculateStrainBasedMissPenalty(this.difficultyAttributes.readingDifficultNoteCount), this.proportionalMissPenalty);
+        // Scale the reading value with estimated full combo deviation.
+        // As reading is easily "bypassable" with memorization, punish for memorization.
+        readingValue *= this.calculateDeviationBasedLengthScaling(undefined, true);
+        // Scale the reading value with deviation.
+        readingValue *=
+            1.05 * osuBase.ErrorFunction.erf(25 / (Math.SQRT2 * this._deviation));
         // OD 5 SS stays the same.
-        visualValue *= 0.98 + Math.pow(5, 2) / 2500;
-        return visualValue;
+        readingValue *= 0.98 + Math.pow(5, 2) / 2500;
+        return readingValue;
     }
     /**
      * The object-based proportional miss penalty.
@@ -2660,7 +2735,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         return multiplier;
     }
     /**
-     * Estimates the player's tap deviation based on the OD, number of circles and sliders,
+     * Estimates the player's 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.
      *
      * The estimation is consistent in that two SS scores on the same map
@@ -2683,19 +2758,21 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         const hitWindow100 = hitWindow.okWindow / clockRate;
         const hitWindow50 = hitWindow.mehWindow / clockRate;
         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);
+        let objectCount = this.difficultyAttributes.hitCircleCount;
+        if (this.mods.has(osuBase.ModScoreV2)) {
+            objectCount += this.difficultyAttributes.sliderCount;
+        }
+        const missCount = Math.min(nmiss, objectCount);
+        const mehCount = Math.min(n50, objectCount - missCount);
+        const okCount = Math.min(n100, objectCount - missCount - mehCount);
+        const greatCount = Math.max(0, objectCount - missCount - mehCount - okCount);
         // 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) {
+        if (greatCount > 0) {
             // The probability that a player hits a circle is unknown, but we can estimate it to be
             // the number of greats on circles divided by the number of circles, and then add one
             // to the number of circles as a bias correction.
-            const greatProbabilityCircle = greatCountCircles /
-                (circleCount - missCountCircles - mehCountCircles + 1);
+            const greatProbabilityCircle = greatCount / (objectCount - missCount - mehCount + 1);
             // Compute the deviation assuming 300s and 100s are normally distributed, and 50s are uniformly distributed.
             // Begin with the normal distribution first.
             let deviationOnCircles = hitWindow300 /
@@ -2714,17 +2791,16 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
                 hitWindow100 * hitWindow100) /
                 3;
             // Find the total deviation.
-            deviationOnCircles = Math.sqrt(((greatCountCircles + okCountCircles) *
-                Math.pow(deviationOnCircles, 2) +
-                mehCountCircles * mehVariance) /
-                (greatCountCircles + okCountCircles + mehCountCircles));
+            deviationOnCircles = Math.sqrt(((greatCount + okCount) * Math.pow(deviationOnCircles, 2) +
+                mehCount * mehVariance) /
+                (greatCount + okCount + mehCount));
             return deviationOnCircles;
         }
         // If there are more non-300s than there are circles, compute the deviation on sliders instead.
         // Here, all that matters is whether or not the slider was missed, since it is impossible
         // 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 missCountSliders = Math.min(sliderCount, nmiss - missCount);
         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.
@@ -2745,7 +2821,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         if (this.totalSuccessfulHits === 0) {
             return Number.POSITIVE_INFINITY;
         }
-        const { speedNoteCount, clockRate } = this.difficultyAttributes;
+        const { clockRate, speedNoteCount } = this.difficultyAttributes;
         const hitWindow = this.getConvertedHitWindow();
         const hitWindow300 = hitWindow.greatWindow / clockRate;
         const hitWindow100 = hitWindow.okWindow / clockRate;
@@ -2754,48 +2830,83 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
         // 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/iskvgjkxr4
         const speedNoteRatio = speedNoteCount / this.totalHits;
-        const nonGreatCount = n100 + n50 + nmiss;
         const nonGreatRatio = 1 -
             (Math.pow(Math.exp(Math.sqrt(hitWindow300)) + 1, 1 - speedNoteRatio) -
                 1) /
                 Math.exp(Math.sqrt(hitWindow300));
-        const relevantCountGreat = Math.max(0, speedNoteCount - nonGreatCount * nonGreatRatio);
-        const relevantCountOk = n100 * nonGreatRatio;
-        const relevantCountMeh = n50 * nonGreatRatio;
-        const relevantCountMiss = nmiss * nonGreatRatio;
-        // Assume 100s, 50s, and misses happen on circles. If there are less non-300s on circles than 300s,
-        // compute the deviation on circles.
-        if (relevantCountGreat > 0) {
-            // The probability that a player hits a circle is unknown, but we can estimate it to be
-            // the number of greats on circles divided by the number of circles, and then add one
-            // to the number of circles as a bias correction.
-            const greatProbabilityCircle = relevantCountGreat /
-                (speedNoteCount - relevantCountMiss - relevantCountMeh + 1);
-            // Compute the deviation assuming 300s and 100s are normally distributed, and 50s are uniformly distributed.
-            // Begin with the normal distribution first.
-            let deviationOnCircles = hitWindow300 /
-                (Math.SQRT2 * osuBase.ErrorFunction.erfInv(greatProbabilityCircle));
-            deviationOnCircles *= Math.sqrt(1 -
-                (Math.sqrt(2 / Math.PI) *
-                    hitWindow100 *
-                    Math.exp(-0.5 *
-                        Math.pow(hitWindow100 / deviationOnCircles, 2))) /
-                    (deviationOnCircles *
-                        osuBase.ErrorFunction.erf(hitWindow100 /
-                            (Math.SQRT2 * deviationOnCircles))));
-            // Then compute the variance for 50s.
-            const mehVariance = (hitWindow50 * hitWindow50 +
-                hitWindow100 * hitWindow50 +
-                hitWindow100 * hitWindow100) /
-                3;
-            // Find the total deviation.
-            deviationOnCircles = Math.sqrt(((relevantCountGreat + relevantCountOk) *
-                Math.pow(deviationOnCircles, 2) +
-                relevantCountMeh * mehVariance) /
-                (relevantCountGreat + relevantCountOk + relevantCountMeh));
-            return deviationOnCircles;
+        // Assume worst case - all non-300s happened in speed notes.
+        const relevantCountMiss = Math.min(nmiss * nonGreatRatio, speedNoteCount);
+        const relevantCountMeh = Math.min(n50 * nonGreatRatio, speedNoteCount - relevantCountMiss);
+        const relevantCountOk = Math.min(n100 * nonGreatRatio, speedNoteCount - relevantCountMiss - relevantCountMeh);
+        const relevantCountGreat = Math.max(0, speedNoteCount -
+            relevantCountMiss -
+            relevantCountMeh -
+            relevantCountOk);
+        if (relevantCountGreat + relevantCountOk + relevantCountMeh <= 0) {
+            return Number.POSITIVE_INFINITY;
         }
-        return Number.POSITIVE_INFINITY;
+        // The sample proportion of successful hits.
+        const n = Math.max(1, relevantCountGreat + relevantCountOk);
+        const p = relevantCountGreat / n;
+        // 99% critical value for the normal distribution (one-tailed).
+        const z = 2.32634787404;
+        // We can be 99% confident that the population proportion is at least this value.
+        const pLowerBound = Math.min(p, (n * p + Math.pow(z, 2) / 2) / (n + Math.pow(z, 2)) -
+            (z / (n + Math.pow(z, 2))) *
+                Math.sqrt(n * p * (1 - p) + Math.pow(z, 2) / 4));
+        let deviation;
+        // Tested maximum precision for the deviation calculation.
+        if (pLowerBound > 0.01) {
+            // Compute deviation assuming 300s and 109s are normally distributed.
+            deviation =
+                hitWindow300 / (Math.SQRT2 * osuBase.ErrorFunction.erfInv(pLowerBound));
+            // Subtract the deviation provided by tails that land outside the 100 hit window from the deviation computed above.
+            // This is equivalent to calculating the deviation of a normal distribution truncated at +-okHitWindow.
+            const hitWindow100TailAmount = (Math.sqrt(2 / Math.PI) *
+                hitWindow100 *
+                Math.exp(-0.5 * Math.pow(hitWindow100 / deviation, 2))) /
+                (deviation *
+                    osuBase.ErrorFunction.erf(hitWindow100 / (Math.SQRT2 * deviation)));
+            deviation *= Math.sqrt(1 - hitWindow100TailAmount);
+        }
+        else {
+            // A tested limit value for the case of a score only containing 100s.
+            deviation = hitWindow100 / Math.sqrt(3);
+        }
+        // Compute and add the variance for 50s, assuming that they are uniformly distriubted.
+        const mehVariance = (hitWindow50 * hitWindow50 +
+            hitWindow100 * hitWindow50 +
+            hitWindow100 * hitWindow100) /
+            3;
+        deviation = Math.sqrt(((relevantCountGreat + relevantCountOk) * Math.pow(deviation, 2) +
+            relevantCountMeh * mehVariance) /
+            (relevantCountGreat + relevantCountOk + relevantCountMeh));
+        return deviation;
+    }
+    /**
+     * Calculates a multiplier for tap to account for improper tapping based on the deviation and tap difficulty.
+     *
+     * [Graph](https://www.desmos.com/calculator/z5l9ebrwpi)
+     */
+    calculateTapHighDeviationNerf() {
+        if (this.tapDeviation == Number.POSITIVE_INFINITY) {
+            return 0;
+        }
+        const tapValue = this.baseValue(this.difficultyAttributes.tapDifficulty);
+        // Decide a point where the PP value achieved compared to the tap deviation is assumed to be tapped
+        // improperly. Any PP above this point is considered "excess" tap difficulty. This is used to cause
+        // PP above the cutoff to scale logarithmically towards the original tap value thus nerfing the value.
+        const excessTapDifficultyCutoff = 100 + 250 * Math.pow(25 / this.tapDeviation, 6.5);
+        if (tapValue <= excessTapDifficultyCutoff) {
+            return 1;
+        }
+        const scale = 50;
+        const adjustedTapValue = scale *
+            (Math.log((tapValue - excessTapDifficultyCutoff) / scale + 1) +
+                excessTapDifficultyCutoff / scale);
+        // 250 UR and less are considered tapped correctly to ensure that normal scores will be punished as little as possible.
+        const t = 1 - osuBase.Interpolation.reverseLerp(this.tapDeviation, 25, 30);
+        return osuBase.Interpolation.lerp(adjustedTapValue, tapValue, t) / tapValue;
     }
     getConvertedHitWindow() {
         const hitWindow300 = new osuBase.OsuHitWindow(this.difficultyAttributes.overallDifficulty).greatWindow;
@@ -2817,8 +2928,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator {
             " acc, " +
             this.flashlight.toFixed(2) +
             " flashlight, " +
-            this.visual.toFixed(2) +
-            " visual)");
+            this.reading.toFixed(2) +
+            " reading)");
     }
 }
 
@@ -2836,19 +2947,10 @@ class OsuDifficultyHitObject extends DifficultyHitObject {
          * The flashlight strain generated by this hitobject.
          */
         this.flashlightStrain = 0;
-        this.radiusBuffThreshold = 30;
         this.mode = osuBase.Modes.osu;
     }
-    get scalingFactor() {
-        const radius = this.object.radius;
-        // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
-        let scalingFactor = DifficultyHitObject.normalizedRadius / radius;
-        // High circle size (small CS) bonus
-        if (radius < this.radiusBuffThreshold) {
-            scalingFactor *=
-                1 + Math.min(this.radiusBuffThreshold - radius, 5) / 50;
-        }
-        return scalingFactor;
+    get smallCircleBonus() {
+        return Math.max(1, 1 + (30 - this.object.radius) / 40);
     }
 }
 
@@ -3439,19 +3541,16 @@ class OsuSpeed extends OsuSkill {
         this.currentSpeedStrain = 0;
         this.currentRhythm = 0;
         this.skillMultiplier = 1.46;
+        this.maxStrain = 0;
     }
     /**
      * The amount of notes that are relevant to the difficulty.
      */
     relevantNoteCount() {
-        if (this._objectStrains.length === 0) {
-            return 0;
-        }
-        const maxStrain = osuBase.MathUtils.max(this._objectStrains);
-        if (maxStrain === 0) {
+        if (this._objectStrains.length === 0 || this.maxStrain === 0) {
             return 0;
         }
-        return this._objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
+        return this._objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / this.maxStrain) * 12 - 6))), 0);
     }
     /**
      * @param current The hitobject to calculate.
@@ -3464,6 +3563,7 @@ class OsuSpeed extends OsuSkill {
         this.currentRhythm = OsuRhythmEvaluator.evaluateDifficultyOf(current);
         const strain = this.currentSpeedStrain * this.currentRhythm;
         this._objectStrains.push(strain);
+        this.maxStrain = Math.max(this.maxStrain, strain);
         return strain;
     }
     calculateInitialStrain(time, current) {
@@ -3549,7 +3649,7 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         const { objects } = beatmap.hitObjects;
         for (let i = 1; i < objects.length; ++i) {
             const difficultyObject = new OsuDifficultyHitObject(objects[i], objects[i - 1], difficultyObjects, clockRate, i - 1);
-            difficultyObject.computeProperties(clockRate, objects);
+            difficultyObject.computeProperties(clockRate);
             difficultyObjects.push(difficultyObject);
         }
         return difficultyObjects;
@@ -3586,7 +3686,7 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         }
         attributes.aimDifficulty = this.calculateRating(aim);
         attributes.aimDifficultSliderCount = aim.countDifficultSliders();
-        attributes.aimDifficultStrainCount = aim.countDifficultStrains();
+        attributes.aimDifficultStrainCount = aim.countTopWeightedStrains();
         if (attributes.aimDifficulty > 0) {
             attributes.sliderFactor =
                 this.calculateRating(aimNoSlider) / attributes.aimDifficulty;
@@ -3602,7 +3702,7 @@ class OsuDifficultyCalculator extends DifficultyCalculator {
         }
         attributes.speedDifficulty = this.calculateRating(speed);
         attributes.speedNoteCount = speed.relevantNoteCount();
-        attributes.speedDifficultStrainCount = speed.countDifficultStrains();
+        attributes.speedDifficultStrainCount = speed.countTopWeightedStrains();
     }
     populateFlashlightAttributes(attributes, skills) {
         const flashlight = skills.find((s) => s instanceof OsuFlashlight);
@@ -3953,12 +4053,12 @@ exports.DroidDifficultyHitObject = DroidDifficultyHitObject;
 exports.DroidFlashlight = DroidFlashlight;
 exports.DroidFlashlightEvaluator = DroidFlashlightEvaluator;
 exports.DroidPerformanceCalculator = DroidPerformanceCalculator;
+exports.DroidReading = DroidReading;
+exports.DroidReadingEvaluator = DroidReadingEvaluator;
 exports.DroidRhythm = DroidRhythm;
 exports.DroidRhythmEvaluator = DroidRhythmEvaluator;
 exports.DroidTap = DroidTap;
 exports.DroidTapEvaluator = DroidTapEvaluator;
-exports.DroidVisual = DroidVisual;
-exports.DroidVisualEvaluator = DroidVisualEvaluator;
 exports.ExtendedDroidDifficultyAttributes = ExtendedDroidDifficultyAttributes;
 exports.OsuAim = OsuAim;
 exports.OsuAimEvaluator = OsuAimEvaluator;