@rian8337/osu-difficulty-calculator 1.2.1 → 1.2.9

package/README.md

@@ -26,7 +26,7 @@ yarn add @rian8337/osu-base @rian8337/osu-difficulty-calculator
 
 # Usage
 
-## General usage
+## Difficulty calculator
 
 ```js
 import { MapInfo } from "@rian8337/osu-base";
@@ -67,7 +67,7 @@ console.log(rating.droidStars);
 console.log(rating.pcStars);
 ```
 
-## Specifying parameters
+### Specifying difficulty calculation parameters
 
 Parameters can be applied to alter the result of the calculation:
 
@@ -104,3 +104,103 @@ console.log(rating.droidStars);
 // osu!standard difficulty
 console.log(rating.pcStars);
 ```
+
+## Performance calculator
+
+```js
+import { MapInfo } from "@rian8337/osu-base";
+import {
+    DroidPerformanceCalculator,
+    MapStars,
+    OsuPerformanceCalculator,
+} from "@rian8337/osu-difficulty-calculator";
+
+const beatmapInfo = await MapInfo.getInformation({ beatmapID: 901854 });
+
+if (!beatmapInfo.title) {
+    return console.log("Beatmap not found");
+}
+
+const rating = new MapStars().calculate({
+    map: beatmapInfo.map,
+});
+
+// osu!droid performance
+const droidPerformance = new DroidPerformanceCalculator().calculate({
+    stars: rating.droidStars,
+});
+
+console.log(droidPerformance);
+
+// osu!standard performance
+const osuPerformance = new OsuPerformanceCalculator().calculate({
+    stars: rating.pcStars,
+});
+
+console.log(osuPerformance);
+```
+
+### Specifying performance calculation parameters
+
+Parameters can be passed to alter the result of the calculation:
+
+-   Combo: The maximum combo achieved. Defaults to the beatmap's maximum combo.
+-   Accuracy: The accuracy achieved. Defaults to 100%.
+-   Misses: The amount of misses achieved.
+-   Tap penalty: Penalty given from three-finger detection. Only applied for osu!droid gamemode. Defaults to 1.
+-   Custom statistics: Used to apply a custom speed multiplier and force AR. Defaults to none.
+
+```js
+import { Accuracy, MapInfo, MapStats } from "@rian8337/osu-base";
+import {
+    OsuPerformanceCalculator,
+    OsuStarRating,
+} from "@rian8337/osu-difficulty-calculator";
+
+const beatmapInfo = await MapInfo.getInformation({ beatmapID: 901854 });
+
+if (!beatmapInfo.title) {
+    return console.log("Beatmap not found");
+}
+
+const rating = new OsuStarRating().calculate({
+    map: beatmapInfo.map,
+});
+
+const accuracy = new Accuracy({
+    // Specify your misses here
+    nmiss: 1,
+
+    // The module provides a convenient way to specify accuracy based on the data that you have
+    // Remove the codes below as you see fit
+
+    // If you have hit data (amount of 300s, 100s, and 50s)
+    n300: 1000,
+    n100: 0,
+    n50: 0,
+
+    // If you have accuracy percentage
+    // While this method is more convenient to use, the amount of 300s, 100s, and 50s will be estimated
+    // This will lead to values being off when calculating for specific accuracies
+    percent: 100,
+    nobjects: beatmapInfo.objects,
+});
+
+const stats = new MapStats({
+    ar: 9.5,
+    isForceAR: true,
+    speedMultiplier: 1.25,
+});
+
+const performance = new OsuPerformanceCalculator().calculate({
+    stars: rating,
+    combo: 1250,
+    accPercent: accuracy,
+    // The tap penalty can be properly obtained by checking a replay for three finger usage
+    // However, a custom value can also be provided
+    tapPenalty: 1.5,
+    stats: stats,
+});
+
+console.log(performance);
+```

package/dist/DroidPerformanceCalculator.js

@@ -51,11 +51,8 @@ class DroidPerformanceCalculator extends PerformanceCalculator_1.PerformanceCalc
      */
     calculateAverageRhythmMultiplier() {
         // The first object doesn't have any rhythm multiplier, so we begin with the second object
-        const rhythmMultipliers = this.stars.objects
-            .map((v) => v.rhythmMultiplier)
-            .slice(1);
-        this.aggregatedRhythmMultiplier = Math.max(1, rhythmMultipliers.reduce((total, value) => total + value, 0) /
-            Math.max(500, rhythmMultipliers.length));
+        const rhythmObjects = this.stars.objects.slice(1);
+        this.aggregatedRhythmMultiplier = Math.max(1, rhythmObjects.reduce((total, value) => total + value.rhythmMultiplier, 0) / Math.max(500, rhythmObjects.length));
     }
     /**
      * Calculates the aim performance value of the beatmap.

package/dist/DroidStarRating.js

@@ -115,7 +115,9 @@ class DroidStarRating extends StarRating_1.StarRating {
         if (!isRelax) {
             this.postCalculateTap(tapSkill);
         }
-        this.calculateSpeedNoteCount();
+        else {
+            this.calculateSpeedNoteCount();
+        }
         if (!isRelax) {
             this.postCalculateRhythm(rhythmSkill);
         }

package/dist/OsuStarRating.js

@@ -35,15 +35,8 @@ class OsuStarRating extends StarRating_1.StarRating {
     calculateAim() {
         const aimSkill = new OsuAim_1.OsuAim(this.mods, true);
         const aimSkillWithoutSliders = new OsuAim_1.OsuAim(this.mods, false);
-        this.calculateSkills(aimSkill);
-        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.calculateSkills(aimSkill, aimSkillWithoutSliders);
+        this.postCalculateAim(aimSkill, aimSkillWithoutSliders);
     }
     /**
      * Calculates the speed star rating of the beatmap and stores it in this instance.
@@ -54,8 +47,7 @@ class OsuStarRating extends StarRating_1.StarRating {
         }
         const speedSkill = new OsuSpeed_1.OsuSpeed(this.mods, new osu_base_1.OsuHitWindow(this.stats.od).hitWindowFor300());
         this.calculateSkills(speedSkill);
-        this.strainPeaks.speed = speedSkill.strainPeaks;
-        this.speed = this.starValue(speedSkill.difficultyValue());
+        this.postCalculateSpeed(speedSkill);
     }
     /**
      * Calculates the flashlight star rating of the beatmap and stores it in this instance.
@@ -63,8 +55,7 @@ class OsuStarRating extends StarRating_1.StarRating {
     calculateFlashlight() {
         const flashlightSkill = new OsuFlashlight_1.OsuFlashlight(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);
@@ -87,10 +78,6 @@ class OsuStarRating 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];
@@ -103,20 +90,11 @@ class OsuStarRating extends StarRating_1.StarRating {
             speedSkill = skills[2];
             flashlightSkill = skills[3];
         }
-        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 (speedSkill) {
-            this.strainPeaks.speed = speedSkill.strainPeaks;
-            this.speed = this.starValue(speedSkill.difficultyValue());
+            this.postCalculateSpeed(speedSkill);
         }
-        this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
-        this.flashlight = this.starValue(flashlightSkill.difficultyValue());
+        this.postCalculateFlashlight(flashlightSkill);
         this.calculateTotal();
     }
     /**
@@ -143,5 +121,39 @@ class OsuStarRating extends StarRating_1.StarRating {
             new OsuFlashlight_1.OsuFlashlight(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 speed skill calculation.
+     *
+     * @param speedSkill The speed skill.
+     */
+    postCalculateSpeed(speedSkill) {
+        this.strainPeaks.speed = speedSkill.strainPeaks;
+        this.speed = this.starValue(speedSkill.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.OsuStarRating = OsuStarRating;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rian8337/osu-difficulty-calculator",
-  "version": "1.2.1",
+  "version": "1.2.9",
   "description": "A module for calculating osu!standard beatmap difficulty and performance value with respect to the current difficulty and performance algorithm.",
   "keywords": [
     "osu",
@@ -11,6 +11,7 @@
   "license": "MIT",
   "main": "dist/index.js",
   "types": "typings/index.d.ts",
+  "typedocMain": "src/index.ts",
   "files": [
     "dist/**",
     "typings/**"
@@ -21,7 +22,6 @@
   },
   "scripts": {
     "build": "tsc",
-    "generate-docs": "typedoc src/index.ts",
     "lint": "eslint --ext ts",
     "prepare": "npm run build",
     "test": "jest -i"
@@ -30,10 +30,10 @@
     "url": "https://github.com/Rian8337/osu-droid-module/issues"
   },
   "dependencies": {
-    "@rian8337/osu-base": "^1.2.1"
+    "@rian8337/osu-base": "^1.2.9"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "8c08cf8f2c3af4b9a306f9fe9ffedfe339b9b046"
+  "gitHead": "4bb4b0c00cf07d5624e1af644a01685697b2832c"
 }

package/typings/index.d.ts

@@ -414,16 +414,6 @@ declare module "@rian8337/osu-difficulty-calculator" {
          * @param flashlightSkill The flashlight skill.
          */
         private postCalculateFlashlight(flashlightSkill: DroidFlashlight): void;
-        /**
-         * Calculates the base rating value of a difficulty.
-         */
-        private baseRatingValue(difficulty: number): number;
-        /**
-         * Calculates the base performance value of a difficulty rating.
-         *
-         * @param rating The difficulty rating.
-         */
-        private basePerformanceValue(rating: number): number;
     }
 
     /**
@@ -716,17 +706,27 @@ declare module "@rian8337/osu-difficulty-calculator" {
          */
         protected override createSkills(): OsuSkill[];
         /**
-         * Calculates the base performance value of a difficulty rating.
+         * Called after aim skill calculation.
          *
-         * @param rating The difficulty rating.
+         * @param aimSkill The aim skill that considers sliders.
+         * @param aimSkillWithoutSliders The aim skill that doesn't consider sliders.
          */
-        private basePerformanceValue(rating: number): number;
+        private postCalculateAim(
+            aimSkill: OsuAim,
+            aimSkillWithoutSliders: OsuAim
+        ): void;
         /**
-         * Calculates the star rating value of a difficulty.
+         * Called after speed skill calculation.
          *
-         * @param difficulty The difficulty to calculate.
+         * @param speedSkill The speed skill.
          */
-        private starValue(difficulty: number): number;
+        private postCalculateSpeed(speedSkill: OsuSpeed): void;
+        /**
+         * Called after flashlight skill calculation.
+         *
+         * @param flashlightSkill The flashlight skill.
+         */
+        private postCalculateFlashlight(flashlightSkill: OsuFlashlight): void;
     }
 
     //#endregion
@@ -872,9 +872,9 @@ declare module "@rian8337/osu-difficulty-calculator" {
              */
             mode?: modes;
             /**
-             * The speed penalty to apply for penalized scores. Only applies to droid gamemode.
+             * The tap penalty to apply for penalized scores. Only applies to droid gamemode.
              */
-            speedPenalty?: number;
+            tapPenalty?: number;
             /**
              * Custom map statistics to apply custom speed multiplier and force AR values as well as old statistics.
              */
@@ -914,9 +914,9 @@ declare module "@rian8337/osu-difficulty-calculator" {
                  */
                 mode?: modes;
                 /**
-                 * The speed penalty to apply for penalized scores.
+                 * The tap penalty to apply for penalized scores.
                  */
-                speedPenalty?: number;
+                tapPenalty?: number;
                 /**
                  * Custom map statistics to apply custom speed multiplier and force AR values as well as old statistics.
                  */
@@ -1061,6 +1061,18 @@ declare module "@rian8337/osu-difficulty-calculator" {
          * Creates skills to be calculated.
          */
         protected abstract createSkills(): Skill[];
+        /**
+         * Calculates the star rating value of a difficulty.
+         *
+         * @param difficulty The difficulty to calculate.
+         */
+        protected starValue(difficulty: number): number;
+        /**
+         * Calculates the base performance value of a difficulty rating.
+         *
+         * @param rating The difficulty rating.
+         */
+        protected basePerformanceValue(rating: number): number;
     }
 
     /**