@rian8337/osu-difficulty-calculator 1.2.9 → 1.4.8

package/dist/DroidPerformanceCalculator.js

@@ -29,22 +29,26 @@ class DroidPerformanceCalculator extends PerformanceCalculator_1.PerformanceCalc
          */
         this.flashlight = 0;
         this.aggregatedRhythmMultiplier = 0;
+        this.tapPenalty = 1;
     }
     calculate(params) {
-        this.handleParams(params, osu_base_1.modes.droid);
+        this.tapPenalty = params.tapPenalty ?? 1;
+        return this.calculateInternal(params, osu_base_1.modes.droid);
+    }
+    calculateValues() {
         this.calculateAverageRhythmMultiplier();
         this.calculateAimValue();
         this.calculateTapValue();
         this.calculateAccuracyValue();
         this.calculateFlashlightValue();
         // Apply tap penalty for penalized plays.
-        this.tap /= params.tapPenalty ?? 1;
-        this.total =
-            Math.pow(Math.pow(this.aim, 1.1) +
-                Math.pow(this.tap, 1.1) +
-                Math.pow(this.accuracy, 1.1) +
-                Math.pow(this.flashlight, 1.1), 1 / 1.1) * this.finalMultiplier;
-        return this;
+        this.tap /= this.tapPenalty;
+    }
+    calculateTotalValue() {
+        return (Math.pow(Math.pow(this.aim, 1.1) +
+            Math.pow(this.tap, 1.1) +
+            Math.pow(this.accuracy, 1.1) +
+            Math.pow(this.flashlight, 1.1), 1 / 1.1) * this.finalMultiplier);
     }
     /**
      * Calculates the average rhythm multiplier of the beatmap.

package/dist/OsuPerformanceCalculator.js

@@ -30,17 +30,19 @@ class OsuPerformanceCalculator extends PerformanceCalculator_1.PerformanceCalcul
         this.flashlight = 0;
     }
     calculate(params) {
-        this.handleParams(params, osu_base_1.modes.osu);
+        return this.calculateInternal(params, osu_base_1.modes.osu);
+    }
+    calculateValues() {
         this.calculateAimValue();
         this.calculateSpeedValue();
         this.calculateAccuracyValue();
         this.calculateFlashlightValue();
-        this.total =
-            Math.pow(Math.pow(this.aim, 1.1) +
-                Math.pow(this.speed, 1.1) +
-                Math.pow(this.accuracy, 1.1) +
-                Math.pow(this.flashlight, 1.1), 1 / 1.1) * this.finalMultiplier;
-        return this;
+    }
+    calculateTotalValue() {
+        return (Math.pow(Math.pow(this.aim, 1.1) +
+            Math.pow(this.speed, 1.1) +
+            Math.pow(this.accuracy, 1.1) +
+            Math.pow(this.flashlight, 1.1), 1 / 1.1) * this.finalMultiplier);
     }
     /**
      * Calculates the aim performance value of the beatmap.

package/dist/base/PerformanceCalculator.js

@@ -33,7 +33,16 @@ class PerformanceCalculator {
         this.sliderNerfFactor = 1;
     }
     /**
-     * Calculates the base performance value for of a star rating.
+     * Internal calculation method, used to process calculation from implementations.
+     */
+    calculateInternal(params, mode) {
+        this.handleParams(params, mode);
+        this.calculateValues();
+        this.total = this.calculateTotalValue();
+        return this;
+    }
+    /**
+     * Calculates the base performance value of a star rating.
      */
     baseValue(stars) {
         return Math.pow(5 * Math.max(1, stars / 0.0675) - 4, 3) / 100000;
@@ -62,7 +71,7 @@ class PerformanceCalculator {
                 nmiss: params.miss || 0,
             });
         }
-        this.effectiveMissCount = this.calculateEffectiveMissCount(combo, maxCombo);
+        this.effectiveMissCount = this.calculateEffectiveMissCount(combo, maxCombo, mode);
         if (this.stars.mods.some((m) => m instanceof osu_base_1.ModNoFail)) {
             this.finalMultiplier *= Math.max(0.9, 1 - 0.02 * this.effectiveMissCount);
         }
@@ -112,7 +121,7 @@ class PerformanceCalculator {
     /**
      * Calculates the amount of misses + sliderbreaks from combo.
      */
-    calculateEffectiveMissCount(combo, maxCombo) {
+    calculateEffectiveMissCount(combo, maxCombo, mode) {
         let comboBasedMissCount = 0;
         if (this.stars.map.sliders > 0) {
             const fullComboThreshold = maxCombo - 0.1 * this.stars.map.sliders;
@@ -122,7 +131,9 @@ class PerformanceCalculator {
                 comboBasedMissCount = Math.min(fullComboThreshold / Math.max(1, combo), this.stars.objects.length);
             }
         }
-        return Math.max(this.computedAccuracy.nmiss, comboBasedMissCount);
+        return Math.max(this.computedAccuracy.nmiss, mode === osu_base_1.modes.droid
+            ? comboBasedMissCount
+            : Math.floor(comboBasedMissCount));
     }
 }
 exports.PerformanceCalculator = PerformanceCalculator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rian8337/osu-difficulty-calculator",
-  "version": "1.2.9",
+  "version": "1.4.8",
   "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.2.9"
+    "@rian8337/osu-base": "^1.4.8"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "4bb4b0c00cf07d5624e1af644a01685697b2832c"
+  "gitHead": "dd3ffd562dcdd8da4f2b48548b936a6012fdff1a"
 }

package/typings/index.d.ts

@@ -233,6 +233,7 @@ declare module "@rian8337/osu-difficulty-calculator" {
          */
         flashlight: number;
         private averageRhythmMultiplier: number;
+        private tapPenalty: number;
         override calculate(params: {
             /**
              * The star rating instance to calculate.
@@ -259,6 +260,8 @@ declare module "@rian8337/osu-difficulty-calculator" {
              */
             stats?: MapStats;
         }): this;
+        protected override calculateValues(): void;
+        protected override calculateTotalValue(): number;
         /**
          * Calculates the average rhythm multiplier of the beatmap.
          */
@@ -587,6 +590,8 @@ declare module "@rian8337/osu-difficulty-calculator" {
              */
             stats?: MapStats;
         }): this;
+        protected override calculateValues(): void;
+        protected override calculateTotalValue(): number;
         /**
          * Calculates the aim performance value of the beatmap.
          */
@@ -867,10 +872,6 @@ declare module "@rian8337/osu-difficulty-calculator" {
              * The amount of misses achieved in the score.
              */
             miss?: number;
-            /**
-             * The gamemode to calculate.
-             */
-            mode?: modes;
             /**
              * The tap penalty to apply for penalized scores. Only applies to droid gamemode.
              */
@@ -885,13 +886,53 @@ declare module "@rian8337/osu-difficulty-calculator" {
          */
         abstract toString(): string;
         /**
-         * Calculates the base performance value for of a star rating.
+         * Internal calculation method, used to process calculation from implementations.
+         */
+        protected calculateInternal(
+            params: {
+                /**
+                 * The star rating instance to calculate.
+                 */
+                stars: StarRating;
+                /**
+                 * The maximum combo achieved in the score.
+                 */
+                combo?: number;
+                /**
+                 * The accuracy achieved in the score.
+                 */
+                accPercent?: Accuracy | number;
+                /**
+                 * The amount of misses achieved in the score.
+                 */
+                miss?: number;
+                /**
+                 * The tap penalty to apply for penalized scores. Only applies to droid gamemode.
+                 */
+                tapPenalty?: number;
+                /**
+                 * Custom map statistics to apply custom speed multiplier and force AR values as well as old statistics.
+                 */
+                stats?: MapStats;
+            },
+            mode: modes
+        ): this;
+        /**
+         * Calculates values that will be used for calculating the total performance value of the beatmap.
+         */
+        protected abstract calculateValues(): void;
+        /**
+         * Calculates the total performance value of the beatmap.
+         */
+        protected abstract calculateTotalValue(): number;
+        /**
+         * Calculates the base performance value of a star rating.
          */
         protected baseValue(stars: number): number;
         /**
          * Processes given parameters for usage in performance calculation.
          */
-        protected handleParams(
+        private handleParams(
             params: {
                 /**
                  * The star rating instance to calculate.
@@ -909,10 +950,6 @@ declare module "@rian8337/osu-difficulty-calculator" {
                  * The amount of misses achieved in the score.
                  */
                 miss?: number;
-                /**
-                 * The gamemode to calculate.
-                 */
-                mode?: modes;
                 /**
                  * The tap penalty to apply for penalized scores.
                  */
@@ -929,7 +966,8 @@ declare module "@rian8337/osu-difficulty-calculator" {
          */
         private calculateEffectiveMissCount(
             combo: number,
-            maxCombo: number
+            maxCombo: number,
+            mode: modes
         ): number;
     }