@rian8337/osu-difficulty-calculator 1.0.2 → 1.1.1

package/dist/DroidPerformanceCalculator.js

@@ -74,18 +74,16 @@ class DroidPerformanceCalculator extends PerformanceCalculator_1.PerformanceCalc
         // Combo scaling
         this.aim *= this.comboPenalty;
         // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
-        let hiddenBonus = 1;
         if (this.stars.mods.some((m) => m instanceof osu_base_1.ModHidden)) {
             // The bonus starts decreasing twice as fast
             // beyond AR10 and reaches 1 at AR11.
             if (calculatedAR > 10) {
-                hiddenBonus += Math.max(0, 0.08 * (11 - calculatedAR));
+                this.aim *= 1 + Math.max(0, 0.08 * (11 - calculatedAR));
             }
             else {
-                hiddenBonus += 0.04 * (12 - calculatedAR);
+                this.aim *= 1 + 0.04 * (12 - calculatedAR);
             }
         }
-        this.aim *= hiddenBonus;
         // AR scaling
         let arFactor = 0;
         if (calculatedAR > 10.33) {

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.
          */
@@ -67,9 +72,6 @@ class DroidStarRating extends StarRating_1.StarRating {
      * 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;
@@ -80,6 +82,14 @@ class DroidStarRating extends StarRating_1.StarRating {
             this.attributes.speedNoteCount = objectStrains.reduce((total, next) => total + 1 / (1 + Math.exp(-((next / maxStrain) * 12 - 6))), 0);
         }
     }
+    /**
+     * 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.rhythm = this.starValue(rhythmSkill.difficultyValue());
+    }
     /**
      * Calculates the flashlight star rating of the beatmap and stores it in this instance.
      */
@@ -91,12 +101,12 @@ class DroidStarRating extends StarRating_1.StarRating {
     }
     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,22 +119,12 @@ 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;
-        if (!isRelax) {
-            tapSkill = skills[2];
-            flashlightSkill = skills[3];
-        }
-        else {
-            flashlightSkill = skills[2];
-        }
+        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());
@@ -133,15 +133,17 @@ class DroidStarRating extends StarRating_1.StarRating {
                 this.starValue(aimSkillWithoutSliders.difficultyValue()) /
                     this.aim;
         }
-        if (tapSkill) {
+        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);
-            }
+        }
+        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 (!isRelax) {
+            this.rhythm = this.starValue(rhythmSkill.difficultyValue());
         }
         this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
         this.flashlight = this.starValue(flashlightSkill.difficultyValue());
@@ -157,6 +159,8 @@ class DroidStarRating extends StarRating_1.StarRating {
             " aim, " +
             this.tap.toFixed(2) +
             " tap, " +
+            this.rhythm.toFixed(2) +
+            " rhythm, " +
             this.flashlight.toFixed(2) +
             " flashlight)");
     }
@@ -167,6 +171,8 @@ 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),
         ];

package/dist/OsuPerformanceCalculator.js

@@ -77,11 +77,9 @@ class OsuPerformanceCalculator extends PerformanceCalculator_1.PerformanceCalcul
         // Buff for longer maps with high AR.
         this.aim *= 1 + arFactor * lengthBonus;
         // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
-        let hiddenBonus = 1;
         if (this.stars.mods.some((m) => m instanceof osu_base_1.ModHidden)) {
-            hiddenBonus += 0.04 * (12 - calculatedAR);
+            this.aim *= 1 + 0.04 * (12 - calculatedAR);
         }
-        this.aim *= hiddenBonus;
         // Scale the aim value with slider factor to nerf very likely dropped sliderends.
         this.aim *= this.sliderNerfFactor;
         // Scale the aim value with accuracy.

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,

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/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.
@@ -43,7 +39,7 @@ class DroidTap extends DroidSkill_1.DroidSkill {
         // 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() /
+            new osu_base_1.OsuHitWindow(this.hitWindow.overallDifficulty - 21.5).hitWindowFor300() /
             0.35, 0.9, 1);
         let speedBonus = 1;
         if (strainTime < this.minSpeedBonus) {
@@ -57,7 +53,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 +60,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 +79,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.2",
+  "version": "1.1.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.2"
+    "@rian8337/osu-base": "^1.0.5"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "34e161583bc0e9beb122e91f2b51ea6706e38736"
+  "gitHead": "595c6aac626f4346807f6da868c86324fed52422"
 }

package/typings/index.d.ts

@@ -1,5 +1,15 @@
 declare module "@rian8337/osu-difficulty-calculator" {
-    import { Accuracy, Beatmap, HitObject, MapStats, Mod, modes, OsuHitWindow, Slider, Vector2 } from "@rian8337/osu-base";
+    import {
+        Accuracy,
+        Beatmap,
+        HitObject,
+        MapStats,
+        Mod,
+        modes,
+        OsuHitWindow,
+        Slider,
+        Vector2,
+    } from "@rian8337/osu-base";
 
     //#region Classes
 
@@ -15,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;
         /**
@@ -30,16 +41,20 @@ 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.
          */
         flashlightStrain: number;
         /**
          * The normalized distance from the "lazy" end position of the previous hitobject to the start position of this hitobject.
-         * 
+         *
          * The "lazy" end position is the position at which the cursor ends up if the previous hitobject is followed with as minimal movement as possible (i.e. on the edge of slider follow circles).
          */
         lazyJumpDistance: number;
@@ -267,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.
      */
@@ -393,6 +431,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.
      */
@@ -822,7 +895,10 @@ declare module "@rian8337/osu-difficulty-calculator" {
         /**
          * Calculates the amount of misses + sliderbreaks from combo.
          */
-        private calculateEffectiveMissCount(combo: number, maxCombo: number): number;
+        private calculateEffectiveMissCount(
+            combo: number,
+            maxCombo: number
+        ): number;
     }
 
     /**