@rian8337/osu-difficulty-calculator 1.1.0 → 1.2.1

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,31 +59,15 @@ 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.
      */
     calculateTap() {
-        if (this.mods.some((m) => m instanceof osu_base_1.ModRelax)) {
-            return;
-        }
         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.
@@ -91,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.
@@ -99,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);
@@ -122,48 +105,21 @@ class DroidStarRating extends StarRating_1.StarRating {
     calculateAll() {
         const skills = this.createSkills();
         const isRelax = this.mods.some((m) => m instanceof osu_base_1.ModRelax);
-        if (isRelax) {
-            // Remove tap and rhythm skill to prevent overhead. These values will be 0 anyways.
-            skills.splice(2, 2);
-        }
         this.calculateSkills(...skills);
         const aimSkill = skills[0];
         const aimSkillWithoutSliders = skills[1];
-        let tapSkill;
-        let rhythmSkill;
-        let flashlightSkill;
+        const rhythmSkill = skills[2];
+        const tapSkill = skills[3];
+        const flashlightSkill = skills[4];
+        this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
         if (!isRelax) {
-            rhythmSkill = skills[2];
-            tapSkill = skills[3];
-            flashlightSkill = skills[4];
-        }
-        else {
-            flashlightSkill = skills[2];
+            this.postCalculateTap(tapSkill);
         }
-        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;
-        }
-        if (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);
-            }
-        }
-        if (rhythmSkill) {
-            this.calculateSkills(rhythmSkill);
-            this.rhythm = this.starValue(rhythmSkill.difficultyValue());
+        this.calculateSpeedNoteCount();
+        if (!isRelax) {
+            this.postCalculateRhythm(rhythmSkill);
         }
-        this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
-        this.flashlight = this.starValue(flashlightSkill.difficultyValue());
+        this.postCalculateFlashlight(flashlightSkill);
         this.calculateTotal();
     }
     /**
@@ -194,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

@@ -62,8 +62,9 @@ class PerformanceCalculator {
                 nmiss: params.miss || 0,
             });
         }
+        this.effectiveMissCount = this.calculateEffectiveMissCount(combo, maxCombo);
         if (this.stars.mods.some((m) => m instanceof osu_base_1.ModNoFail)) {
-            this.finalMultiplier *= Math.max(0.9, 1 - 0.02 * this.computedAccuracy.nmiss);
+            this.finalMultiplier *= Math.max(0.9, 1 - 0.02 * this.effectiveMissCount);
         }
         if (this.stars.mods.some((m) => m instanceof osu_base_1.ModSpunOut)) {
             this.finalMultiplier *=
@@ -71,11 +72,13 @@ class PerformanceCalculator {
                     Math.pow(this.stars.map.spinners / this.stars.objects.length, 0.85);
         }
         if (this.stars.mods.some((m) => m instanceof osu_base_1.ModRelax)) {
-            this.computedAccuracy.nmiss +=
-                this.computedAccuracy.n100 + this.computedAccuracy.n50;
+            // As we're adding 100s and 50s to an approximated number of combo breaks, the result can be higher
+            // than total hits in specific scenarios (which breaks some calculations),  so we need to clamp it.
+            this.effectiveMissCount = Math.min(this.effectiveMissCount +
+                this.computedAccuracy.n100 +
+                this.computedAccuracy.n50, this.stars.objects.length);
             this.finalMultiplier *= 0.6;
         }
-        this.effectiveMissCount = this.calculateEffectiveMissCount(combo, maxCombo);
         this.mapStatistics = new osu_base_1.MapStats({
             ar: baseAR,
             od: baseOD,
@@ -119,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.0",
+  "version": "1.2.1",
   "description": "A module for calculating osu!standard beatmap difficulty and performance value with respect to the current difficulty and performance algorithm.",
   "keywords": [
     "osu",
@@ -30,10 +30,10 @@
     "url": "https://github.com/Rian8337/osu-droid-module/issues"
   },
   "dependencies": {
-    "@rian8337/osu-base": "^1.0.5"
+    "@rian8337/osu-base": "^1.2.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "409e4106e7d7297924a55c625d4214fb0ba79a18"
+  "gitHead": "8c08cf8f2c3af4b9a306f9fe9ffedfe339b9b046"
 }

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.
          */