@rian8337/osu-difficulty-calculator 1.0.4 → 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

@@ -6,6 +6,7 @@ const DroidTap_1 = require("./skills/DroidTap");
 const StarRating_1 = require("./base/StarRating");
 const DroidFlashlight_1 = require("./skills/DroidFlashlight");
 const osu_base_1 = require("@rian8337/osu-base");
+const DroidRhythm_1 = require("./skills/DroidRhythm");
 /**
  * Difficulty calculator for osu!droid gamemode.
  */
@@ -20,6 +21,10 @@ class DroidStarRating extends StarRating_1.StarRating {
          * The tap star rating of the beatmap.
          */
         this.tap = 0;
+        /**
+         * The rhythm star rating of the beatmap.
+         */
+        this.rhythm = 0;
         /**
          * The flashlight star rating of the beatmap.
          */
@@ -54,31 +59,23 @@ 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.
+     */
+    calculateRhythm() {
+        const rhythmSkill = new DroidRhythm_1.DroidRhythm(this.mods, this.stats.od);
+        this.calculateSkills(rhythmSkill);
+        this.postCalculateRhythm(rhythmSkill);
     }
     /**
      * Calculates the flashlight star rating of the beatmap and stores it in this instance.
@@ -86,17 +83,16 @@ 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);
-        const speedPerformanceValue = this.basePerformanceValue(this.tap);
+        const tapPerformanceValue = this.basePerformanceValue(this.tap);
         const flashlightPerformanceValue = this.mods.some((m) => m instanceof osu_base_1.ModFlashlight)
             ? Math.pow(this.flashlight, 2) * 25
             : 0;
         const basePerformanceValue = Math.pow(Math.pow(aimPerformanceValue, 1.1) +
-            Math.pow(speedPerformanceValue, 1.1) +
+            Math.pow(tapPerformanceValue, 1.1) +
             Math.pow(flashlightPerformanceValue, 1.1), 1 / 1.1);
         if (basePerformanceValue > 1e-5) {
             this.total =
@@ -109,42 +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 speed skill to prevent overhead
-            skills.splice(2, 1);
-        }
         this.calculateSkills(...skills);
         const aimSkill = skills[0];
         const aimSkillWithoutSliders = skills[1];
-        let tapSkill;
-        let flashlightSkill;
+        const rhythmSkill = skills[2];
+        const tapSkill = skills[3];
+        const flashlightSkill = skills[4];
+        this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
         if (!isRelax) {
-            tapSkill = skills[2];
-            flashlightSkill = skills[3];
-        }
-        else {
-            flashlightSkill = skills[2];
-        }
-        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.postCalculateTap(tapSkill);
         }
-        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);
-            }
+        this.calculateSpeedNoteCount();
+        if (!isRelax) {
+            this.postCalculateRhythm(rhythmSkill);
         }
-        this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
-        this.flashlight = this.starValue(flashlightSkill.difficultyValue());
+        this.postCalculateFlashlight(flashlightSkill);
         this.calculateTotal();
     }
     /**
@@ -157,6 +132,8 @@ class DroidStarRating extends StarRating_1.StarRating {
             " aim, " +
             this.tap.toFixed(2) +
             " tap, " +
+            this.rhythm.toFixed(2) +
+            " rhythm, " +
             this.flashlight.toFixed(2) +
             " flashlight)");
     }
@@ -167,9 +144,64 @@ class DroidStarRating extends StarRating_1.StarRating {
         return [
             new DroidAim_1.DroidAim(this.mods, true),
             new DroidAim_1.DroidAim(this.mods, false),
+            // Tap skill depends on rhythm skill, so we put it first
+            new DroidRhythm_1.DroidRhythm(this.mods, this.stats.od),
             new DroidTap_1.DroidTap(this.mods, this.stats.od),
             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/index.js

@@ -15,6 +15,7 @@ __exportStar(require("./preprocessing/DifficultyHitObjectCreator"), exports);
 __exportStar(require("./skills/DroidAim"), exports);
 __exportStar(require("./skills/DroidFlashlight"), exports);
 __exportStar(require("./DroidPerformanceCalculator"), exports);
+__exportStar(require("./skills/DroidRhythm"), exports);
 __exportStar(require("./DroidStarRating"), exports);
 __exportStar(require("./skills/DroidTap"), exports);
 __exportStar(require("./MapStars"), exports);

package/dist/preprocessing/DifficultyHitObject.js

@@ -19,6 +19,8 @@ class DifficultyHitObject {
         this.aimStrainWithoutSliders = 0;
         /**
          * The tap strain generated by the hitobject.
+         *
+         * This is also used for osu!standard as opposed to "speed strain".
          */
         this.tapStrain = 0;
         /**
@@ -27,9 +29,13 @@ class DifficultyHitObject {
          */
         this.originalTapStrain = 0;
         /**
-         * The rhythm multiplier generated by the hitobject.
+         * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
          */
         this.rhythmMultiplier = 0;
+        /**
+         * The rhythm strain generated by the hitobject.
+         */
+        this.rhythmStrain = 0;
         /**
          * The flashlight strain generated by the hitobject.
          */

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/DroidRhythm.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DroidRhythm = void 0;
+const osu_base_1 = require("@rian8337/osu-base");
+const DroidSkill_1 = require("./DroidSkill");
+/**
+ * Represents the skill required to properly follow a beatmap's rhythm.
+ */
+class DroidRhythm extends DroidSkill_1.DroidSkill {
+    constructor(mods, overallDifficulty) {
+        super(mods);
+        this.historyLength = 32;
+        this.skillMultiplier = 1;
+        this.reducedSectionCount = 5;
+        this.reducedSectionBaseline = 0.75;
+        this.strainDecayBase = 0.3;
+        this.starsPerDouble = 2;
+        this.rhythmMultiplier = 0.75;
+        this.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
+        this.currentRhythm = 1;
+        this.hitWindow = new osu_base_1.OsuHitWindow(overallDifficulty);
+    }
+    /**
+     * Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current object.
+     */
+    calculateRhythmBonus(current) {
+        if (current.object instanceof osu_base_1.Spinner) {
+            return 0;
+        }
+        let previousIslandSize = 0;
+        let rhythmComplexitySum = 0;
+        let islandSize = 1;
+        // Store the ratio of the current start of an island to buff for tighter rhythms.
+        let startRatio = 0;
+        let firstDeltaSwitch = false;
+        let rhythmStart = 0;
+        while (rhythmStart < this.previous.length - 2 &&
+            current.startTime - this.previous[rhythmStart].startTime <
+                this.historyTimeMax) {
+            ++rhythmStart;
+        }
+        for (let i = rhythmStart; i > 0; --i) {
+            // Scale note 0 to 1 from history to now.
+            let currentHistoricalDecay = (this.historyTimeMax -
+                (current.startTime - this.previous[i - 1].startTime)) /
+                this.historyTimeMax;
+            // Either we're limited by time or limited by object count.
+            currentHistoricalDecay = Math.min(currentHistoricalDecay, (this.previous.length - i) / this.previous.length);
+            const currentDelta = this.previous[i - 1].strainTime;
+            const prevDelta = this.previous[i].strainTime;
+            const lastDelta = this.previous[i + 1].strainTime;
+            const currentRatio = 1 +
+                6 *
+                    Math.min(0.5, Math.pow(Math.sin(Math.PI /
+                        (Math.min(prevDelta, currentDelta) /
+                            Math.max(prevDelta, currentDelta))), 2));
+            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) -
+                this.hitWindow.hitWindowFor300() * 0.6) /
+                (this.hitWindow.hitWindowFor300() * 0.6));
+            let effectiveRatio = windowPenalty * currentRatio;
+            if (firstDeltaSwitch) {
+                if (prevDelta <= 1.25 * currentDelta &&
+                    prevDelta * 1.25 >= currentDelta) {
+                    // Island is still progressing, count size.
+                    if (islandSize < 7) {
+                        ++islandSize;
+                    }
+                }
+                else {
+                    if (this.previous[i - 1].object instanceof osu_base_1.Slider) {
+                        // BPM change is into slider, this is easy acc window.
+                        effectiveRatio /= 8;
+                    }
+                    if (this.previous[i].object instanceof osu_base_1.Slider) {
+                        // BPM change was from a slider, this is typically easier than circle -> circle.
+                        effectiveRatio /= 4;
+                    }
+                    if (previousIslandSize === islandSize) {
+                        // Repeated island size (ex: triplet -> triplet).
+                        effectiveRatio /= 4;
+                    }
+                    if (previousIslandSize % 2 === islandSize % 2) {
+                        // Repeated island polarity (2 -> 4, 3 -> 5).
+                        effectiveRatio /= 2;
+                    }
+                    if (lastDelta > prevDelta + 10 &&
+                        prevDelta > currentDelta + 10) {
+                        // Previous increase happened a note ago.
+                        // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
+                        effectiveRatio /= 8;
+                    }
+                    rhythmComplexitySum +=
+                        (((Math.sqrt(effectiveRatio * startRatio) *
+                            currentHistoricalDecay *
+                            Math.sqrt(4 + islandSize)) /
+                            2) *
+                            Math.sqrt(4 + previousIslandSize)) /
+                            2;
+                    startRatio = effectiveRatio;
+                    previousIslandSize = islandSize;
+                    if (prevDelta * 1.25 < currentDelta) {
+                        // We're slowing down, stop counting.
+                        // If we're speeding up, this stays as is and we keep counting island size.
+                        firstDeltaSwitch = false;
+                    }
+                    islandSize = 1;
+                }
+            }
+            else if (prevDelta > 1.25 * currentDelta) {
+                // We want to be speeding up.
+                // Begin counting island until we change speed again.
+                firstDeltaSwitch = true;
+                startRatio = effectiveRatio;
+                islandSize = 1;
+            }
+        }
+        return Math.sqrt(4 + rhythmComplexitySum * this.rhythmMultiplier) / 2;
+    }
+    strainValueAt(current) {
+        this.currentRhythm = this.calculateRhythmBonus(current);
+        this.currentStrain *= this.strainDecay(current.deltaTime);
+        this.currentStrain += this.currentRhythm - 1;
+        return this.currentStrain;
+    }
+    saveToHitObject(current) {
+        current.rhythmStrain = this.currentStrain;
+        current.rhythmMultiplier = this.currentRhythm;
+    }
+}
+exports.DroidRhythm = DroidRhythm;

package/dist/skills/DroidTap.js

@@ -19,11 +19,7 @@ class DroidTap extends DroidSkill_1.DroidSkill {
         this.minSpeedBonus = 75;
         this.currentTapStrain = 0;
         this.currentOriginalTapStrain = 0;
-        this.rhythmMultiplier = 0.75;
-        this.historyTimeMax = 5000; // 5 seconds of calculateRhythmBonus max.
-        this.currentRhythm = 1;
-        this.overallDifficulty = overallDifficulty;
-        this.hitWindow = new osu_base_1.OsuHitWindow(this.overallDifficulty);
+        this.hitWindow = new osu_base_1.OsuHitWindow(overallDifficulty);
     }
     /**
      * @param current The hitobject to calculate.
@@ -41,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.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 +=
@@ -57,7 +51,6 @@ class DroidTap extends DroidSkill_1.DroidSkill {
                     Math.pow((this.minSpeedBonus - current.strainTime) / 40, 2);
         }
         const decay = this.strainDecay(current.deltaTime);
-        this.currentRhythm = this.calculateRhythmBonus(current);
         this.currentTapStrain *= decay;
         this.currentTapStrain +=
             this.tapStrainOf(speedBonus, strainTime) * this.skillMultiplier;
@@ -65,103 +58,7 @@ class DroidTap extends DroidSkill_1.DroidSkill {
         this.currentOriginalTapStrain +=
             this.tapStrainOf(originalSpeedBonus, current.strainTime) *
                 this.skillMultiplier;
-        return this.currentTapStrain * this.currentRhythm;
-    }
-    /**
-     * Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current object.
-     */
-    calculateRhythmBonus(current) {
-        if (current.object instanceof osu_base_1.Spinner) {
-            return 0;
-        }
-        let previousIslandSize = 0;
-        let rhythmComplexitySum = 0;
-        let islandSize = 1;
-        // Store the ratio of the current start of an island to buff for tighter rhythms.
-        let startRatio = 0;
-        let firstDeltaSwitch = false;
-        let rhythmStart = 0;
-        while (rhythmStart < this.previous.length - 2 &&
-            current.startTime - this.previous[rhythmStart].startTime <
-                this.historyTimeMax) {
-            ++rhythmStart;
-        }
-        for (let i = rhythmStart; i > 0; --i) {
-            // Scale note 0 to 1 from history to now.
-            let currentHistoricalDecay = (this.historyTimeMax -
-                (current.startTime - this.previous[i - 1].startTime)) /
-                this.historyTimeMax;
-            // Either we're limited by time or limited by object count.
-            currentHistoricalDecay = Math.min(currentHistoricalDecay, (this.previous.length - i) / this.previous.length);
-            const currentDelta = this.previous[i - 1].strainTime;
-            const prevDelta = this.previous[i].strainTime;
-            const lastDelta = this.previous[i + 1].strainTime;
-            const currentRatio = 1 +
-                6 *
-                    Math.min(0.5, Math.pow(Math.sin(Math.PI /
-                        (Math.min(prevDelta, currentDelta) /
-                            Math.max(prevDelta, currentDelta))), 2));
-            const windowPenalty = Math.min(1, Math.max(0, Math.abs(prevDelta - currentDelta) -
-                this.hitWindow.hitWindowFor300() * 0.6) /
-                (this.hitWindow.hitWindowFor300() * 0.6));
-            let effectiveRatio = windowPenalty * currentRatio;
-            if (firstDeltaSwitch) {
-                if (prevDelta <= 1.25 * currentDelta &&
-                    prevDelta * 1.25 >= currentDelta) {
-                    // Island is still progressing, count size.
-                    if (islandSize < 7) {
-                        ++islandSize;
-                    }
-                }
-                else {
-                    if (this.previous[i - 1].object instanceof osu_base_1.Slider) {
-                        // BPM change is into slider, this is easy acc window.
-                        effectiveRatio /= 8;
-                    }
-                    if (this.previous[i].object instanceof osu_base_1.Slider) {
-                        // BPM change was from a slider, this is typically easier than circle -> circle.
-                        effectiveRatio /= 4;
-                    }
-                    if (previousIslandSize === islandSize) {
-                        // Repeated island size (ex: triplet -> triplet).
-                        effectiveRatio /= 4;
-                    }
-                    if (previousIslandSize % 2 === islandSize % 2) {
-                        // Repeated island polarity (2 -> 4, 3 -> 5).
-                        effectiveRatio /= 2;
-                    }
-                    if (lastDelta > prevDelta + 10 &&
-                        prevDelta > currentDelta + 10) {
-                        // Previous increase happened a note ago.
-                        // Albeit this is a 1/1 -> 1/2-1/4 type of transition, we don't want to buff this.
-                        effectiveRatio /= 8;
-                    }
-                    rhythmComplexitySum +=
-                        (((Math.sqrt(effectiveRatio * startRatio) *
-                            currentHistoricalDecay *
-                            Math.sqrt(4 + islandSize)) /
-                            2) *
-                            Math.sqrt(4 + previousIslandSize)) /
-                            2;
-                    startRatio = effectiveRatio;
-                    previousIslandSize = islandSize;
-                    if (prevDelta * 1.25 < currentDelta) {
-                        // We're slowing down, stop counting.
-                        // If we're speeding up, this stays as is and we keep counting island size.
-                        firstDeltaSwitch = false;
-                    }
-                    islandSize = 1;
-                }
-            }
-            else if (prevDelta > 1.25 * currentDelta) {
-                // We want to be speeding up.
-                // Begin counting island until we change speed again.
-                firstDeltaSwitch = true;
-                startRatio = effectiveRatio;
-                islandSize = 1;
-            }
-        }
-        return Math.sqrt(4 + rhythmComplexitySum * this.rhythmMultiplier) / 2;
+        return this.currentTapStrain * current.rhythmMultiplier;
     }
     /**
      * Calculates the tap strain of a hitobject given a specific speed bonus and strain time.
@@ -180,9 +77,8 @@ class DroidTap extends DroidSkill_1.DroidSkill {
      */
     saveToHitObject(current) {
         current.tapStrain = this.currentStrain;
-        current.rhythmMultiplier = this.currentRhythm;
         current.originalTapStrain =
-            this.currentOriginalTapStrain * this.currentRhythm;
+            this.currentOriginalTapStrain * current.rhythmMultiplier;
     }
 }
 exports.DroidTap = DroidTap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rian8337/osu-difficulty-calculator",
-  "version": "1.0.4",
+  "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",
@@ -30,10 +30,10 @@
     "url": "https://github.com/Rian8337/osu-droid-module/issues"
   },
   "dependencies": {
-    "@rian8337/osu-base": "^1.0.4"
+    "@rian8337/osu-base": "^1.0.5"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "31e88dedb78e6b1e0123b67bcc5d4dd31f5dfc60"
+  "gitHead": "745e369ae1c5895e7a58188cb522eaecac618966"
 }

package/typings/index.d.ts

@@ -25,13 +25,14 @@ declare module "@rian8337/osu-difficulty-calculator" {
          * The aim strain generated by the hitobject if sliders are considered.
          */
         aimStrainWithSliders: number;
-
         /**
          * The aim strain generated by the hitobject if sliders are not considered.
          */
         aimStrainWithoutSliders: number;
         /**
          * The tap strain generated by the hitobject.
+         *
+         * This is also used for osu!standard as opposed to "speed strain".
          */
         tapStrain: number;
         /**
@@ -40,9 +41,13 @@ declare module "@rian8337/osu-difficulty-calculator" {
          */
         originalTapStrain: number;
         /**
-         * The rhythm multiplier generated by the hitobject.
+         * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
          */
         rhythmMultiplier: number;
+        /**
+         * The rhythm strain generated by the hitobject.
+         */
+        rhythmStrain: number;
         /**
          * The flashlight strain generated by the hitobject.
          */
@@ -277,6 +282,29 @@ declare module "@rian8337/osu-difficulty-calculator" {
         override toString(): string;
     }
 
+    /**
+     * Represents the skill required to properly follow a beatmap's rhythm.
+     */
+    export class DroidRhythm extends DroidSkill {
+        protected override readonly historyLength: number;
+        protected override readonly skillMultiplier: number;
+        protected override readonly reducedSectionCount: number;
+        protected override readonly reducedSectionBaseline: number;
+        protected override readonly strainDecayBase: number;
+        protected override readonly starsPerDouble: number;
+        private readonly rhythmMultiplier: number;
+        private readonly historyTimeMax: number;
+        private currentRhythm: number;
+        private readonly hitWindow: OsuHitWindow;
+        constructor(mods: Mod[], overallDifficulty: number);
+        /**
+         * Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current object.
+         */
+        private calculateRhythmBonus(current: DifficultyHitObject): number;
+        protected override strainValueAt(current: DifficultyHitObject): number;
+        protected override saveToHitObject(current: DifficultyHitObject): void;
+    }
+
     /**
      * Difficulty calculator for osu!droid gamemode.
      */
@@ -354,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.
          */
@@ -403,6 +463,41 @@ declare module "@rian8337/osu-difficulty-calculator" {
         protected override saveToHitObject(current: DifficultyHitObject): void;
     }
 
+    /**
+     * A star rating calculator that configures which mode to calculate difficulty for and what mods are applied.
+     */
+    export class MapStars {
+        /**
+         * The osu!droid star rating of the beatmap.
+         */
+        readonly droidStars: DroidStarRating;
+        /**
+         * The osu!standard star rating of the beatmap.
+         */
+        readonly pcStars: OsuStarRating;
+        /**
+         * Calculates the star rating of a beatmap.
+         */
+        calculate(params: {
+            /**
+             * The beatmap to calculate.
+             */
+            map: Beatmap;
+            /**
+             * Applied modifications.
+             */
+            mods?: Mod[];
+            /**
+             * Custom map statistics to apply speed multiplier and force AR values as well as old statistics.
+             */
+            stats?: MapStats;
+        }): MapStars;
+        /**
+         * Returns a string representative of the class.
+         */
+        toString(): string;
+    }
+
     /**
      * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
      */