@rian8337/osu-difficulty-calculator 4.0.0-beta.48 → 4.0.0-beta.49

package/dist/index.js

@@ -27,6 +27,7 @@ AimEvaluator.wideAngleMultiplier = 1.5;
 AimEvaluator.acuteAngleMultiplier = 1.95;
 AimEvaluator.sliderMultiplier = 1.35;
 AimEvaluator.velocityChangeMultiplier = 0.75;
+AimEvaluator.wiggleMultiplier = 1.02;
 
 /**
  * The base of a difficulty calculator.
@@ -175,6 +176,12 @@ class DifficultyCalculator {
  * Represents a hit object with difficulty calculation values.
  */
 class DifficultyHitObject {
+    /**
+     * The normalized diameter of the hitobject.
+     */
+    static get normalizedDiameter() {
+        return this.normalizedRadius * 2;
+    }
     /**
      * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
      * overridden properties (see [this](https://github.com/microsoft/TypeScript/issues/1617) GitHub issue).
@@ -236,9 +243,8 @@ class DifficultyHitObject {
          * Calculated as the angle between the circles (current-2, current-1, current).
          */
         this.angle = null;
-        this.normalizedRadius = 50;
-        this.maximumSliderRadius = this.normalizedRadius * 2.4;
-        this.assumedSliderRadius = this.normalizedRadius * 1.8;
+        this.maximumSliderRadius = DifficultyHitObject.normalizedRadius * 2.4;
+        this.assumedSliderRadius = DifficultyHitObject.normalizedRadius * 1.8;
         this.object = object;
         this.lastObject = lastObject;
         this.lastLastObject = lastLastObject;
@@ -442,7 +448,7 @@ class DifficultyHitObject {
             .getStackedPosition(this.mode)
             .add(slider.path.positionAt(endTimeMin));
         let currentCursorPosition = slider.getStackedPosition(this.mode);
-        const scalingFactor = this.normalizedRadius / slider.radius;
+        const scalingFactor = DifficultyHitObject.normalizedRadius / slider.radius;
         for (let i = 1; i < slider.nestedHitObjects.length; ++i) {
             const currentMovementObject = slider.nestedHitObjects[i];
             let currentMovement = currentMovementObject
@@ -464,7 +470,7 @@ class DifficultyHitObject {
             }
             else if (currentMovementObject instanceof osuBase.SliderRepeat) {
                 // For a slider repeat, assume a tighter movement threshold to better assess repeat sliders.
-                requiredMovement = this.normalizedRadius;
+                requiredMovement = DifficultyHitObject.normalizedRadius;
             }
             if (currentMovementLength > requiredMovement) {
                 // This finds the positional delta from the required radius and the current position,
@@ -491,11 +497,211 @@ class DifficultyHitObject {
         return pos;
     }
 }
+/**
+ * The normalized radius of the hitobject.
+ */
+DifficultyHitObject.normalizedRadius = 50;
 /**
  * The lowest possible delta time value.
  */
 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;
+    }
+    /**
+     * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
+     * overridden properties (see [this](https://github.com/microsoft/TypeScript/issues/1617) GitHub issue).
+     *
+     * @param object The underlying hitobject.
+     * @param lastObject The hitobject before this hitobject.
+     * @param lastLastObject The hitobject before the last hitobject.
+     * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
+     * @param clockRate The clock rate of the beatmap.
+     */
+    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate) {
+        super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate);
+        /**
+         * The tap strain generated by the hitobject.
+         */
+        this.tapStrain = 0;
+        /**
+         * The tap strain generated by the hitobject if `strainTime` isn't modified by
+         * OD. This is used in three-finger detection.
+         */
+        this.originalTapStrain = 0;
+        /**
+         * The rhythm strain generated by the hitobject.
+         */
+        this.rhythmStrain = 0;
+        /**
+         * The flashlight strain generated by the hitobject if sliders are considered.
+         */
+        this.flashlightStrainWithSliders = 0;
+        /**
+         * The flashlight strain generated by the hitobject if sliders are not considered.
+         */
+        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.
+         */
+        this.visualStrainWithoutSliders = 0;
+        /**
+         * The note density of the hitobject.
+         */
+        this.noteDensity = 1;
+        /**
+         * The overlapping factor of the hitobject.
+         *
+         * This is used to scale visual skill.
+         */
+        this.overlappingFactor = 0;
+        this.radiusBuffThreshold = 70;
+        this.mode = osuBase.Modes.droid;
+        this.maximumSliderRadius = DifficultyHitObject.normalizedRadius * 2;
+        this.timePreempt = object.timePreempt / clockRate;
+    }
+    computeProperties(clockRate, hitObjects) {
+        super.computeProperties(clockRate, hitObjects);
+        this.setVisuals(clockRate, hitObjects);
+    }
+    /**
+     * Determines whether this hitobject is considered overlapping with the hitobject before it.
+     *
+     * Keep in mind that "overlapping" in this case is overlapping to the point where both hitobjects
+     * can be hit with just a single tap in osu!droid.
+     *
+     * In the case of sliders, it is considered overlapping if all nested hitobjects can be hit with
+     * one aim motion.
+     *
+     * @param considerDistance Whether to consider the distance between both hitobjects.
+     * @returns Whether the hitobject is considered overlapping.
+     */
+    isOverlapping(considerDistance) {
+        if (this.object instanceof osuBase.Spinner) {
+            return false;
+        }
+        const prev = this.previous(0);
+        if (!prev || prev.object instanceof osuBase.Spinner) {
+            return false;
+        }
+        if (this.object.startTime !== prev.object.startTime) {
+            return false;
+        }
+        if (!considerDistance) {
+            return true;
+        }
+        const distanceThreshold = 2 * this.object.radius;
+        const startPosition = this.object.getStackedPosition(osuBase.Modes.droid);
+        const prevStartPosition = prev.object.getStackedPosition(osuBase.Modes.droid);
+        // We need to consider two cases:
+        //
+        // Case 1: Current object is a circle, or previous object is a circle.
+        // In this case, we only need to check if their positions are close enough to be tapped together.
+        //
+        // Case 2: Both objects are sliders.
+        // In this case, we need to check if all nested hitobjects can be hit together.
+        // To start with, check if the starting positions can be tapped together.
+        if (startPosition.getDistance(prevStartPosition) > distanceThreshold) {
+            return false;
+        }
+        if (this.object instanceof osuBase.Circle || prev.object instanceof osuBase.Circle) {
+            return true;
+        }
+        // Check if all nested hitobjects can be hit together.
+        for (let i = 1; i < this.object.nestedHitObjects.length; ++i) {
+            const position = this.object.nestedHitObjects[i].getStackedPosition(osuBase.Modes.droid);
+            const prevPosition = prevStartPosition.add(prev.object.curvePositionAt(i / (this.object.nestedHitObjects.length - 1)));
+            if (position.getDistance(prevPosition) > distanceThreshold) {
+                return false;
+            }
+        }
+        // Do the same for the previous slider as well.
+        for (let i = 1; i < prev.object.nestedHitObjects.length; ++i) {
+            const prevPosition = prev.object.nestedHitObjects[i].getStackedPosition(osuBase.Modes.droid);
+            const position = startPosition.add(this.object.curvePositionAt(i / (prev.object.nestedHitObjects.length - 1)));
+            if (prevPosition.getDistance(position) > distanceThreshold) {
+                return false;
+            }
+        }
+        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
+                .getStackedPosition(this.mode)
+                .getDistance(hitObject.getStackedEndPosition(this.mode));
+            const deltaTime = this.startTime - hitObject.endTime / clockRate;
+            this.applyToOverlappingFactor(distance, deltaTime);
+        }
+        for (const hitObject of nextVisibleObjects) {
+            const distance = hitObject
+                .getStackedPosition(this.mode)
+                .getDistance(this.object.getStackedEndPosition(this.mode));
+            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))));
+    }
+}
+
 /**
  * An evaluator for calculating osu!droid Aim skill.
  */
@@ -531,6 +737,8 @@ class DroidAimEvaluator extends AimEvaluator {
         }
         const last = current.previous(0);
         const lastLast = current.previous(1);
+        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.
         let currentVelocity = current.lazyJumpDistance / current.strainTime;
         // But if the last object is a slider, then we extend the travel velocity through the slider into the current object.
@@ -557,6 +765,7 @@ class DroidAimEvaluator extends AimEvaluator {
         let acuteAngleBonus = 0;
         let sliderBonus = 0;
         let velocityChangeBonus = 0;
+        let wiggleBonus = 0;
         // Start strain with regular velocity.
         let strain = currentVelocity;
         if (
@@ -566,40 +775,40 @@ class DroidAimEvaluator extends AimEvaluator {
             current.angle !== null &&
             last.angle !== null &&
             lastLast.angle !== null) {
+            const currentAngle = current.angle;
+            const lastAngle = last.angle;
             // Rewarding angles, take the smaller velocity as base.
             const angleBonus = Math.min(currentVelocity, prevVelocity);
             wideAngleBonus = this.calculateWideAngleBonus(current.angle);
             acuteAngleBonus = this.calculateAcuteAngleBonus(current.angle);
-            // Only buff deltaTime exceeding 300 BPM 1/2.
-            if (current.strainTime > 100) {
-                acuteAngleBonus = 0;
-            }
-            else {
-                acuteAngleBonus *=
-                    // Multiply by previous angle, we don't want to buff unless this is a wiggle type pattern.
-                    this.calculateAcuteAngleBonus(last.angle) *
-                        // The maximum velocity we buff is equal to 125 / strainTime.
-                        Math.min(angleBonus, 125 / current.strainTime) *
-                        // Scale buff from 300 BPM 1/2 to 400 BPM 1/2.
-                        Math.pow(Math.sin((Math.PI / 2) *
-                            Math.min(1, (100 - current.strainTime) / 25)), 2) *
-                        // Buff distance exceeding 50 (radius) up to 100 (diameter).
-                        Math.pow(Math.sin(((Math.PI / 2) *
-                            (osuBase.MathUtils.clamp(current.lazyJumpDistance, 50, 100) -
-                                50)) /
-                            50), 2);
-            }
-            // Penalize wide angles if they're repeated, reducing the penalty as last.angle gets more acute.
+            // Penalize angle repetition.
             wideAngleBonus *=
-                angleBonus *
-                    (1 -
-                        Math.min(wideAngleBonus, Math.pow(this.calculateWideAngleBonus(last.angle), 3)));
-            // Penalize acute angles if they're repeated, reducing the penalty as lastLast.angle gets more obtuse.
+                1 -
+                    Math.min(wideAngleBonus, Math.pow(this.calculateWideAngleBonus(lastAngle), 3));
             acuteAngleBonus *=
-                0.5 +
-                    0.5 *
+                0.08 +
+                    0.92 *
                         (1 -
-                            Math.min(acuteAngleBonus, Math.pow(this.calculateAcuteAngleBonus(lastLast.angle), 3)));
+                            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 =
+                angleBonus *
+                    osuBase.MathUtils.smootherstep(current.lazyJumpDistance, radius, diameter) *
+                    Math.pow(osuBase.MathUtils.reverseLerp(current.lazyJumpDistance, diameter * 3, diameter), 1.8) *
+                    osuBase.MathUtils.smootherstep(currentAngle, osuBase.MathUtils.degreesToRadians(110), osuBase.MathUtils.degreesToRadians(60)) *
+                    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 (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.
@@ -623,6 +832,7 @@ class DroidAimEvaluator extends AimEvaluator {
             // Reward sliders based on velocity.
             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);
@@ -648,10 +858,17 @@ class DroidAimEvaluator extends AimEvaluator {
         const shortDistancePenalty = Math.pow(Math.min(this.singleSpacingThreshold, travelDistance + current.minimumJumpDistance) / this.singleSpacingThreshold, 3.5);
         return (200 * speedBonus * shortDistancePenalty) / current.strainTime;
     }
+    static calculateWideAngleBonus(angle) {
+        return osuBase.MathUtils.smoothstep(angle, osuBase.MathUtils.degreesToRadians(40), osuBase.MathUtils.degreesToRadians(140));
+    }
+    static calculateAcuteAngleBonus(angle) {
+        return osuBase.MathUtils.smoothstep(angle, osuBase.MathUtils.degreesToRadians(140), osuBase.MathUtils.degreesToRadians(40));
+    }
 }
-DroidAimEvaluator.wideAngleMultiplier = 1.65;
-DroidAimEvaluator.sliderMultiplier = 1.5;
-DroidAimEvaluator.velocityChangeMultiplier = 0.85;
+DroidAimEvaluator.wideAngleMultiplier = 1.5;
+DroidAimEvaluator.acuteAngleMultiplier = 2.6;
+DroidAimEvaluator.sliderMultiplier = 1.35;
+DroidAimEvaluator.velocityChangeMultiplier = 0.75;
 DroidAimEvaluator.singleSpacingThreshold = 100;
 // 200 1/4 BPM delta time
 DroidAimEvaluator.minSpeedBonus = 75;
@@ -805,15 +1022,33 @@ class DroidAim extends DroidSkill {
         this.reducedSectionCount = 10;
         this.reducedSectionBaseline = 0.75;
         this.starsPerDouble = 1.05;
-        this.skillMultiplier = 24.55;
+        this.skillMultiplier = 25.6;
         this.currentAimStrain = 0;
+        this.sliderStrains = [];
         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 = Math.max(...this.sliderStrains);
+        if (maxSliderStrain === 0) {
+            return 0;
+        }
+        return this.sliderStrains.reduce((total, strain) => total +
+            1 / (1 + Math.exp(-((strain / maxSliderStrain) * 12 - 6))), 0);
+    }
     strainValueAt(current) {
         this.currentAimStrain *= this.strainDecay(current.deltaTime);
         this.currentAimStrain +=
             DroidAimEvaluator.evaluateDifficultyOf(current, this.withSliders) *
                 this.skillMultiplier;
+        if (current.object instanceof osuBase.Slider) {
+            this.sliderStrains.push(this.currentAimStrain);
+        }
         return this.currentAimStrain;
     }
     calculateInitialStrain(time, current) {
@@ -884,7 +1119,7 @@ class DroidTapEvaluator extends SpeedEvaluator {
                 0.75 *
                     Math.pow(osuBase.ErrorFunction.erf((this.minSpeedBonus - strainTime) / 40), 2);
         }
-        return (speedBonus * Math.pow(doubletapness, 1.5)) / strainTime;
+        return (speedBonus * Math.pow(doubletapness, 1.5) * 1000) / strainTime;
     }
 }
 
@@ -906,7 +1141,7 @@ class DroidTap extends DroidSkill {
         this.starsPerDouble = 1.1;
         this.currentTapStrain = 0;
         this.currentRhythmMultiplier = 0;
-        this.skillMultiplier = 1375;
+        this.skillMultiplier = 1.375;
         this._objectDeltaTimes = [];
         this.considerCheesability = considerCheesability;
         this.strainTimeCap = strainTimeCap;
@@ -1021,13 +1256,13 @@ class DroidFlashlightEvaluator extends FlashlightEvaluator {
         let angleRepeatCount = 0;
         for (let i = 0; i < Math.min(current.index, 10); ++i) {
             const currentObject = current.previous(i);
+            cumulativeStrainTime += last.strainTime;
             if (!(currentObject.object instanceof osuBase.Spinner) &&
                 // Exclude overlapping objects that can be tapped at once.
                 !currentObject.isOverlapping(false)) {
                 const jumpDistance = current.object
                     .getStackedPosition(osuBase.Modes.droid)
                     .subtract(currentObject.object.getStackedEndPosition(osuBase.Modes.droid)).length;
-                cumulativeStrainTime += last.strainTime;
                 // We want to nerf objects that can be easily seen within the Flashlight circle radius.
                 if (i === 0) {
                     smallDistNerf = Math.min(1, jumpDistance / 75);
@@ -1263,7 +1498,7 @@ class DroidRhythmEvaluator {
                         }
                         // Repeated island (ex: triplet -> triplet).
                         // Graph: https://www.desmos.com/calculator/pj7an56zwf
-                        effectiveRatio *= Math.min(3 / islandCount, Math.pow(1 / islandCount, 2.75 / (1 + Math.exp(14 - 0.24 * island.delta))));
+                        effectiveRatio *= Math.min(3 / islandCount, Math.pow(1 / islandCount, osuBase.MathUtils.offsetLogistic(island.delta, 58.33, 0.24, 2.75)));
                         break;
                     }
                     if (!islandFound) {
@@ -1487,202 +1722,6 @@ class DroidVisual extends DroidSkill {
     }
 }
 
-/**
- * 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 = this.normalizedRadius / radius;
-        // High circle size (small CS) bonus
-        if (radius < this.radiusBuffThreshold) {
-            scalingFactor *=
-                1 + Math.pow((this.radiusBuffThreshold - radius) / 50, 2);
-        }
-        return scalingFactor;
-    }
-    /**
-     * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
-     * overridden properties (see [this](https://github.com/microsoft/TypeScript/issues/1617) GitHub issue).
-     *
-     * @param object The underlying hitobject.
-     * @param lastObject The hitobject before this hitobject.
-     * @param lastLastObject The hitobject before the last hitobject.
-     * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
-     * @param clockRate The clock rate of the beatmap.
-     */
-    constructor(object, lastObject, lastLastObject, difficultyHitObjects, clockRate) {
-        super(object, lastObject, lastLastObject, difficultyHitObjects, clockRate);
-        /**
-         * The tap strain generated by the hitobject.
-         */
-        this.tapStrain = 0;
-        /**
-         * The tap strain generated by the hitobject if `strainTime` isn't modified by
-         * OD. This is used in three-finger detection.
-         */
-        this.originalTapStrain = 0;
-        /**
-         * The rhythm strain generated by the hitobject.
-         */
-        this.rhythmStrain = 0;
-        /**
-         * The flashlight strain generated by the hitobject if sliders are considered.
-         */
-        this.flashlightStrainWithSliders = 0;
-        /**
-         * The flashlight strain generated by the hitobject if sliders are not considered.
-         */
-        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.
-         */
-        this.visualStrainWithoutSliders = 0;
-        /**
-         * The note density of the hitobject.
-         */
-        this.noteDensity = 1;
-        /**
-         * The overlapping factor of the hitobject.
-         *
-         * This is used to scale visual skill.
-         */
-        this.overlappingFactor = 0;
-        this.radiusBuffThreshold = 70;
-        this.mode = osuBase.Modes.droid;
-        this.maximumSliderRadius = this.normalizedRadius * 2;
-        this.timePreempt = object.timePreempt / clockRate;
-    }
-    computeProperties(clockRate, hitObjects) {
-        super.computeProperties(clockRate, hitObjects);
-        this.setVisuals(clockRate, hitObjects);
-    }
-    /**
-     * Determines whether this hitobject is considered overlapping with the hitobject before it.
-     *
-     * Keep in mind that "overlapping" in this case is overlapping to the point where both hitobjects
-     * can be hit with just a single tap in osu!droid.
-     *
-     * In the case of sliders, it is considered overlapping if all nested hitobjects can be hit with
-     * one aim motion.
-     *
-     * @param considerDistance Whether to consider the distance between both hitobjects.
-     * @returns Whether the hitobject is considered overlapping.
-     */
-    isOverlapping(considerDistance) {
-        if (this.object instanceof osuBase.Spinner) {
-            return false;
-        }
-        const prev = this.previous(0);
-        if (!prev || prev.object instanceof osuBase.Spinner) {
-            return false;
-        }
-        if (this.object.startTime !== prev.object.startTime) {
-            return false;
-        }
-        if (!considerDistance) {
-            return true;
-        }
-        const distanceThreshold = 2 * this.object.radius;
-        const startPosition = this.object.getStackedPosition(osuBase.Modes.droid);
-        const prevStartPosition = prev.object.getStackedPosition(osuBase.Modes.droid);
-        // We need to consider two cases:
-        //
-        // Case 1: Current object is a circle, or previous object is a circle.
-        // In this case, we only need to check if their positions are close enough to be tapped together.
-        //
-        // Case 2: Both objects are sliders.
-        // In this case, we need to check if all nested hitobjects can be hit together.
-        // To start with, check if the starting positions can be tapped together.
-        if (startPosition.getDistance(prevStartPosition) > distanceThreshold) {
-            return false;
-        }
-        if (this.object instanceof osuBase.Circle || prev.object instanceof osuBase.Circle) {
-            return true;
-        }
-        // Check if all nested hitobjects can be hit together.
-        for (let i = 1; i < this.object.nestedHitObjects.length; ++i) {
-            const position = this.object.nestedHitObjects[i].getStackedPosition(osuBase.Modes.droid);
-            const prevPosition = prevStartPosition.add(prev.object.curvePositionAt(i / (this.object.nestedHitObjects.length - 1)));
-            if (position.getDistance(prevPosition) > distanceThreshold) {
-                return false;
-            }
-        }
-        // Do the same for the previous slider as well.
-        for (let i = 1; i < prev.object.nestedHitObjects.length; ++i) {
-            const prevPosition = prev.object.nestedHitObjects[i].getStackedPosition(osuBase.Modes.droid);
-            const position = startPosition.add(this.object.curvePositionAt(i / (prev.object.nestedHitObjects.length - 1)));
-            if (prevPosition.getDistance(position) > distanceThreshold) {
-                return false;
-            }
-        }
-        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
-                .getStackedPosition(this.mode)
-                .getDistance(hitObject.getStackedEndPosition(this.mode));
-            const deltaTime = this.startTime - hitObject.endTime / clockRate;
-            this.applyToOverlappingFactor(distance, deltaTime);
-        }
-        for (const hitObject of nextVisibleObjects) {
-            const distance = hitObject
-                .getStackedPosition(this.mode)
-                .getDistance(this.object.getStackedEndPosition(this.mode));
-            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))));
-    }
-}
-
 /**
  * A difficulty calculator for osu!droid gamemode.
  */
@@ -1691,6 +1730,7 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         super(...arguments);
         this.attributes = {
             mode: "live",
+            aimDifficultSliderCount: 0,
             tapDifficulty: 0,
             rhythmDifficulty: 0,
             visualDifficulty: 0,
@@ -1918,6 +1958,8 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         }
         this.attributes.aimDifficultStrainCount =
             aimSkill.countDifficultStrains();
+        this.attributes.aimDifficultSliderCount =
+            aimSkill.countDifficultSliders();
         this.calculateAimAttributes();
     }
     /**
@@ -2051,6 +2093,9 @@ class DroidDifficultyCalculator extends DifficultyCalculator {
         if (this.mods.some((m) => m instanceof osuBase.ModRelax)) {
             this.attributes.flashlightDifficulty *= 0.7;
         }
+        else if (this.mods.some((m) => m instanceof osuBase.ModAutopilot)) {
+            this.attributes.flashlightDifficulty *= 0.4;
+        }
         this.attributes.flashlightDifficultStrainCount =
             flashlightSkill.countDifficultStrains();
     }
@@ -3356,7 +3401,7 @@ class OsuDifficultyHitObject extends DifficultyHitObject {
     get scalingFactor() {
         const radius = this.object.radius;
         // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
-        let scalingFactor = this.normalizedRadius / radius;
+        let scalingFactor = DifficultyHitObject.normalizedRadius / radius;
         // High circle size (small CS) bonus
         if (radius < this.radiusBuffThreshold) {
             scalingFactor *=

package/package.json

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

package/typings/index.d.ts

@@ -10,6 +10,7 @@ declare abstract class AimEvaluator {
     protected static readonly acuteAngleMultiplier: number;
     protected static readonly sliderMultiplier: number;
     protected static readonly velocityChangeMultiplier: number;
+    protected static readonly wiggleMultiplier: number;
     /**
      * Calculates the bonus of wide angles.
      */
@@ -197,8 +198,15 @@ declare abstract class DifficultyHitObject {
      * Other hitobjects in the beatmap, including this hitobject.
      */
     protected readonly hitObjects: readonly DifficultyHitObject[];
+    /**
+     * The normalized radius of the hitobject.
+     */
+    static readonly normalizedRadius: number;
+    /**
+     * The normalized diameter of the hitobject.
+     */
+    static get normalizedDiameter(): number;
     protected abstract readonly mode: Modes;
-    protected readonly normalizedRadius = 50;
     protected readonly maximumSliderRadius: number;
     protected readonly assumedSliderRadius: number;
     /**
@@ -647,7 +655,12 @@ declare class DroidAim extends DroidSkill {
     private readonly skillMultiplier;
     private readonly withSliders;
     private currentAimStrain;
+    private readonly sliderStrains;
     constructor(mods: Mod[], withSliders: boolean);
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
+     */
+    countDifficultSliders(): number;
     protected strainValueAt(current: DroidDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
     protected getObjectStrain(): number;
@@ -661,9 +674,10 @@ declare class DroidAim extends DroidSkill {
  * An evaluator for calculating osu!droid Aim skill.
  */
 declare abstract class DroidAimEvaluator extends AimEvaluator {
-    protected static readonly wideAngleMultiplier = 1.65;
-    protected static readonly sliderMultiplier = 1.5;
-    protected static readonly velocityChangeMultiplier = 0.85;
+    protected static readonly wideAngleMultiplier = 1.5;
+    protected static readonly acuteAngleMultiplier = 2.6;
+    protected static readonly sliderMultiplier = 1.35;
+    protected static readonly velocityChangeMultiplier = 0.75;
     private static readonly singleSpacingThreshold;
     private static readonly minSpeedBonus;
     /**
@@ -686,12 +700,18 @@ declare abstract class DroidAimEvaluator extends AimEvaluator {
      * Calculates the flow aim strain of a hitobject.
      */
     private static flowAimStrainOf;
+    protected static calculateWideAngleBonus(angle: number): number;
+    protected static calculateAcuteAngleBonus(angle: number): number;
 }
 
 /**
  * Holds data that can be used to calculate osu!droid performance points.
  */
 interface DroidDifficultyAttributes extends DifficultyAttributes {
+    /**
+     * The number of sliders weighted by difficulty.
+     */
+    aimDifficultSliderCount: number;
     /**
      * The difficulty corresponding to the tap skill.
      */