@rian8337/osu-difficulty-calculator 1.1.1 → 1.2.0

package/dist/DroidPerformanceCalculator.js

@@ -153,7 +153,7 @@ class DroidPerformanceCalculator extends PerformanceCalculator_1.PerformanceCalc
             (0.95 + (od > 0 ? odScaling : -odScaling)) *
                 Math.pow((this.computedAccuracy.value(objectCount) +
                     relevantAccuracy.value(this.stars.attributes.speedNoteCount)) /
-                    2, (12 - Math.max(od, 2.5)) / 2);
+                    2, (14 - Math.max(od, 2.5)) / 2);
         // Scale the speed value with # of 50s to punish doubletapping.
         this.tap *= Math.pow(0.98, Math.max(0, this.computedAccuracy.n50 - objectCount / 500));
     }

package/dist/DroidStarRating.js

@@ -59,14 +59,7 @@ class DroidStarRating extends StarRating_1.StarRating {
         const aimSkill = new DroidAim_1.DroidAim(this.mods, true);
         const aimSkillWithoutSliders = new DroidAim_1.DroidAim(this.mods, false);
         this.calculateSkills(aimSkill, aimSkillWithoutSliders);
-        this.strainPeaks.aimWithSliders = aimSkill.strainPeaks;
-        this.strainPeaks.aimWithoutSliders = aimSkillWithoutSliders.strainPeaks;
-        this.aim = this.starValue(aimSkill.difficultyValue());
-        if (this.aim) {
-            this.attributes.sliderFactor =
-                this.starValue(aimSkillWithoutSliders.difficultyValue()) /
-                    this.aim;
-        }
+        this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
     }
     /**
      * Calculates the speed star rating of the beatmap and stores it in this instance.
@@ -74,13 +67,7 @@ class DroidStarRating extends StarRating_1.StarRating {
     calculateTap() {
         const tapSkill = new DroidTap_1.DroidTap(this.mods, this.stats.od);
         this.calculateSkills(tapSkill);
-        this.strainPeaks.speed = tapSkill.strainPeaks;
-        this.tap = this.starValue(tapSkill.difficultyValue());
-        const objectStrains = this.objects.map((v) => v.tapStrain);
-        const maxStrain = Math.max(...objectStrains);
-        if (maxStrain) {
-            this.attributes.speedNoteCount = objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
-        }
+        this.postCalculateTap(tapSkill);
     }
     /**
      * Calculates the rhythm star rating of the beatmap and stores it in this instance.
@@ -88,7 +75,7 @@ class DroidStarRating extends StarRating_1.StarRating {
     calculateRhythm() {
         const rhythmSkill = new DroidRhythm_1.DroidRhythm(this.mods, this.stats.od);
         this.calculateSkills(rhythmSkill);
-        this.rhythm = this.starValue(rhythmSkill.difficultyValue());
+        this.postCalculateRhythm(rhythmSkill);
     }
     /**
      * Calculates the flashlight star rating of the beatmap and stores it in this instance.
@@ -96,8 +83,7 @@ class DroidStarRating extends StarRating_1.StarRating {
     calculateFlashlight() {
         const flashlightSkill = new DroidFlashlight_1.DroidFlashlight(this.mods);
         this.calculateSkills(flashlightSkill);
-        this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
-        this.flashlight = this.starValue(flashlightSkill.difficultyValue());
+        this.postCalculateFlashlight(flashlightSkill);
     }
     calculateTotal() {
         const aimPerformanceValue = this.basePerformanceValue(this.aim);
@@ -125,28 +111,15 @@ class DroidStarRating extends StarRating_1.StarRating {
         const rhythmSkill = skills[2];
         const tapSkill = skills[3];
         const flashlightSkill = skills[4];
-        this.strainPeaks.aimWithSliders = aimSkill.strainPeaks;
-        this.strainPeaks.aimWithoutSliders = aimSkillWithoutSliders.strainPeaks;
-        this.aim = this.starValue(aimSkill.difficultyValue());
-        if (this.aim) {
-            this.attributes.sliderFactor =
-                this.starValue(aimSkillWithoutSliders.difficultyValue()) /
-                    this.aim;
-        }
+        this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
         if (!isRelax) {
-            this.strainPeaks.speed = tapSkill.strainPeaks;
-            this.tap = this.starValue(tapSkill.difficultyValue());
-        }
-        const objectStrains = this.objects.map((v) => v.tapStrain);
-        const maxStrain = Math.max(...objectStrains);
-        if (maxStrain) {
-            this.attributes.speedNoteCount = objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
+            this.postCalculateTap(tapSkill);
         }
+        this.calculateSpeedNoteCount();
         if (!isRelax) {
-            this.rhythm = this.starValue(rhythmSkill.difficultyValue());
+            this.postCalculateRhythm(rhythmSkill);
         }
-        this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
-        this.flashlight = this.starValue(flashlightSkill.difficultyValue());
+        this.postCalculateFlashlight(flashlightSkill);
         this.calculateTotal();
     }
     /**
@@ -177,5 +150,58 @@ class DroidStarRating extends StarRating_1.StarRating {
             new DroidFlashlight_1.DroidFlashlight(this.mods),
         ];
     }
+    /**
+     * Called after aim skill calculation.
+     *
+     * @param aimSkill The aim skill that considers sliders.
+     * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
+     */
+    postCalculateAim(aimSkill, aimSkillWithoutSliders) {
+        this.strainPeaks.aimWithSliders = aimSkill.strainPeaks;
+        this.strainPeaks.aimWithoutSliders = aimSkillWithoutSliders.strainPeaks;
+        this.aim = this.starValue(aimSkill.difficultyValue());
+        if (this.aim) {
+            this.attributes.sliderFactor =
+                this.starValue(aimSkillWithoutSliders.difficultyValue()) /
+                    this.aim;
+        }
+    }
+    /**
+     * Called after tap skill calculation.
+     *
+     * @param tapSkill The tap skill.
+     */
+    postCalculateTap(tapSkill) {
+        this.strainPeaks.speed = tapSkill.strainPeaks;
+        this.tap = this.starValue(tapSkill.difficultyValue());
+        this.calculateSpeedNoteCount();
+    }
+    /**
+     * Calculates the speed note count attribute.
+     */
+    calculateSpeedNoteCount() {
+        const objectStrains = this.objects.map((v) => v.tapStrain);
+        const maxStrain = Math.max(...objectStrains);
+        if (maxStrain) {
+            this.attributes.speedNoteCount = objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
+        }
+    }
+    /**
+     * Called after rhythm skill calculation.
+     *
+     * @param rhythmSkill The rhythm skill.
+     */
+    postCalculateRhythm(rhythmSkill) {
+        this.rhythm = this.starValue(rhythmSkill.difficultyValue());
+    }
+    /**
+     * Called after flashlight skill calculation.
+     *
+     * @param flashlightSkill The flashlight skill.
+     */
+    postCalculateFlashlight(flashlightSkill) {
+        this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
+        this.flashlight = this.starValue(flashlightSkill.difficultyValue());
+    }
 }
 exports.DroidStarRating = DroidStarRating;

package/dist/base/PerformanceCalculator.js

@@ -122,7 +122,7 @@ class PerformanceCalculator {
                 comboBasedMissCount = Math.min(fullComboThreshold / Math.max(1, combo), this.stars.objects.length);
             }
         }
-        return Math.max(this.computedAccuracy.nmiss, Math.floor(comboBasedMissCount));
+        return Math.max(this.computedAccuracy.nmiss, comboBasedMissCount);
     }
 }
 exports.PerformanceCalculator = PerformanceCalculator;

package/dist/skills/DroidFlashlight.js

@@ -10,7 +10,7 @@ class DroidFlashlight extends DroidSkill_1.DroidSkill {
     constructor() {
         super(...arguments);
         this.historyLength = 10;
-        this.skillMultiplier = 0.15;
+        this.skillMultiplier = 0.07;
         this.strainDecayBase = 0.15;
         this.reducedSectionCount = 10;
         this.reducedSectionBaseline = 0.75;
@@ -24,22 +24,23 @@ class DroidFlashlight extends DroidSkill_1.DroidSkill {
         let smallDistNerf = 1;
         let cumulativeStrainTime = 0;
         let result = 0;
+        let last = current;
         for (let i = 0; i < this.previous.length; ++i) {
-            const previous = this.previous[i];
-            if (previous.object instanceof osu_base_1.Spinner) {
-                continue;
+            const currentObject = this.previous[i];
+            if (!(currentObject.object instanceof osu_base_1.Spinner)) {
+                const jumpDistance = current.object.stackedPosition.subtract(currentObject.object.endPosition).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);
+                }
+                // We also want to nerf stacks so that only the first object of the stack is accounted for.
+                const stackNerf = Math.min(1, currentObject.lazyJumpDistance / scalingFactor / 25);
+                result +=
+                    (stackNerf * scalingFactor * jumpDistance) /
+                        cumulativeStrainTime;
             }
-            const jumpDistance = current.object.stackedPosition.subtract(previous.object.endPosition).length;
-            cumulativeStrainTime += previous.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);
-            }
-            // We also want to nerf stacks so that only the first object of the stack is accounted for.
-            const stackNerf = Math.min(1, previous.lazyJumpDistance / scalingFactor / 25);
-            result +=
-                (Math.pow(0.8, i) * stackNerf * scalingFactor * jumpDistance) /
-                    cumulativeStrainTime;
+            last = currentObject;
         }
         return Math.pow(smallDistNerf * result, 2);
     }

package/dist/skills/DroidTap.js

@@ -37,10 +37,8 @@ class DroidTap extends DroidSkill_1.DroidSkill {
             strainTime = osu_base_1.Interpolation.lerp(this.previous[0].strainTime, strainTime, strainTime / greatWindowFull);
         }
         // Cap deltatime to the OD 300 hitwindow.
-        // This equation is derived from making sure 260 BPM 1/4 OD7 streams aren't nerfed harshly.
-        strainTime /= osu_base_1.MathUtils.clamp(strainTime /
-            new osu_base_1.OsuHitWindow(this.hitWindow.overallDifficulty - 21.5).hitWindowFor300() /
-            0.35, 0.9, 1);
+        // 0.58 is derived from making sure 260 BPM 1/4 OD5 streams aren't nerfed harshly, whilst 0.92 limits the effect of the cap.
+        strainTime /= osu_base_1.MathUtils.clamp(strainTime / greatWindowFull / 0.58, 0.92, 1);
         let speedBonus = 1;
         if (strainTime < this.minSpeedBonus) {
             speedBonus +=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rian8337/osu-difficulty-calculator",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "A module for calculating osu!standard beatmap difficulty and performance value with respect to the current difficulty and performance algorithm.",
   "keywords": [
     "osu",
@@ -35,5 +35,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "595c6aac626f4346807f6da868c86324fed52422"
+  "gitHead": "745e369ae1c5895e7a58188cb522eaecac618966"
 }

package/typings/index.d.ts

@@ -382,6 +382,38 @@ declare module "@rian8337/osu-difficulty-calculator" {
          * Creates skills to be calculated.
          */
         protected override createSkills(): DroidSkill[];
+        /**
+         * Called after aim skill calculation.
+         *
+         * @param aimSkill The aim skill that considers sliders.
+         * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
+         */
+        private postCalculateAim(
+            aimSkill: DroidAim,
+            aimSkillWithoutSliders: DroidAim
+        ): void;
+        /**
+         * Called after tap skill calculation.
+         *
+         * @param tapSkill The tap skill.
+         */
+        private postCalculateTap(tapSkill: DroidTap): void;
+        /**
+         * Calculates the speed note count attribute.
+         */
+        private calculateSpeedNoteCount(): void;
+        /**
+         * Called after rhythm skill calculation.
+         *
+         * @param rhythmSkill The rhythm skill.
+         */
+        private postCalculateRhythm(rhythmSkill: DroidRhythm): void;
+        /**
+         * Called after flashlight skill calculation.
+         *
+         * @param flashlightSkill The flashlight skill.
+         */
+        private postCalculateFlashlight(flashlightSkill: DroidFlashlight): void;
         /**
          * Calculates the base rating value of a difficulty.
          */