@rian8337/osu-difficulty-calculator 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Rian8337
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# `osu-difficulty-calculator`
+
+> TODO: description
+
+## Usage
+
+```
+const osuDifficultyCalculator = require('osu-difficulty-calculator');
+
+// TODO: DEMONSTRATE API
+```

package/dist/DroidPerformanceCalculator.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DroidPerformanceCalculator = void 0;
+const DroidStarRating_1 = require("./DroidStarRating");
+const PerformanceCalculator_1 = require("./base/PerformanceCalculator");
+const osu_base_1 = require("@rian8337/osu-base");
+/**
+ * A performance points calculator that calculates performance points for osu!droid gamemode.
+ */
+class DroidPerformanceCalculator extends PerformanceCalculator_1.PerformanceCalculator {
+    constructor() {
+        super(...arguments);
+        this.stars = new DroidStarRating_1.DroidStarRating();
+        this.finalMultiplier = 1.42;
+        /**
+         * The aim performance value.
+         */
+        this.aim = 0;
+        /**
+         * The tap performance value.
+         */
+        this.tap = 0;
+        /**
+         * The accuracy performance value.
+         */
+        this.accuracy = 0;
+        /**
+         * The flashlight performance value.
+         */
+        this.flashlight = 0;
+        this.aggregatedRhythmMultiplier = 0;
+    }
+    calculate(params) {
+        this.handleParams(params, osu_base_1.modes.droid);
+        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;
+    }
+    /**
+     * Calculates the average rhythm multiplier of the beatmap.
+     */
+    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));
+    }
+    /**
+     * Calculates the aim performance value of the beatmap.
+     */
+    calculateAimValue() {
+        // Global variables
+        const objectCount = this.stars.objects.length;
+        const calculatedAR = this.mapStatistics.ar;
+        this.aim = this.baseValue(Math.pow(this.stars.aim, 0.8));
+        if (this.effectiveMissCount > 0) {
+            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
+            this.aim *=
+                0.97 *
+                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), this.effectiveMissCount);
+        }
+        // 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));
+            }
+            else {
+                hiddenBonus += 0.04 * (12 - calculatedAR);
+            }
+        }
+        this.aim *= hiddenBonus;
+        // AR scaling
+        let arFactor = 0;
+        if (calculatedAR > 10.33) {
+            arFactor += 0.3 * (calculatedAR - 10.33);
+        }
+        else if (calculatedAR < 8) {
+            arFactor += 0.1 * (8 - calculatedAR);
+        }
+        // Buff for longer maps with high AR.
+        this.aim *=
+            1 +
+                arFactor *
+                    (1.650668 +
+                        (0.4845796 - 1.650668) /
+                            (1 + Math.pow(objectCount / 817.9306, 1.147469)));
+        // Scale the aim value with slider factor to nerf very likely dropped sliderends.
+        this.aim *= this.sliderNerfFactor;
+        // Scale the aim value with accuracy.
+        this.aim *= this.computedAccuracy.value(objectCount);
+        // It is also important to consider accuracy difficulty when doing that.
+        const odScaling = Math.pow(this.mapStatistics.od, 2) / 2500;
+        this.aim *=
+            0.98 + (this.mapStatistics.od >= 0 ? odScaling : -odScaling);
+    }
+    /**
+     * Calculates the tap performance value of the beatmap.
+     */
+    calculateTapValue() {
+        // Global variables
+        const objectCount = this.stars.objects.length;
+        const calculatedAR = this.mapStatistics.ar;
+        this.tap = this.baseValue(this.stars.tap);
+        if (this.effectiveMissCount > 0) {
+            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
+            this.tap *=
+                0.97 *
+                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), Math.pow(this.effectiveMissCount, 0.875));
+        }
+        // Combo scaling
+        this.tap *= this.comboPenalty;
+        // AR scaling
+        if (calculatedAR > 10.33) {
+            // Buff for longer maps with high AR.
+            this.tap *=
+                1 +
+                    0.3 *
+                        (calculatedAR - 10.33) *
+                        (1.650668 +
+                            (0.4845796 - 1.650668) /
+                                (1 + Math.pow(objectCount / 817.9306, 1.147469)));
+        }
+        // Calculate accuracy assuming the worst case scenario.
+        const countGreat = this.computedAccuracy.n300;
+        const countOk = this.computedAccuracy.n100;
+        const countMeh = this.computedAccuracy.n50;
+        const relevantTotalDiff = objectCount - this.stars.attributes.speedNoteCount;
+        const relevantAccuracy = new osu_base_1.Accuracy({
+            n300: Math.max(0, countGreat - relevantTotalDiff),
+            n100: Math.max(0, countOk - Math.max(0, relevantTotalDiff - countGreat)),
+            n50: Math.max(0, countMeh - Math.max(0, relevantTotalDiff - countGreat - countOk)),
+            nmiss: this.effectiveMissCount,
+        });
+        // Scale the speed value with accuracy and OD.
+        const od = this.mapStatistics.od;
+        const odScaling = Math.pow(od, 2) / 750;
+        this.tap *=
+            (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);
+        // Scale the speed value with # of 50s to punish doubletapping.
+        this.tap *= Math.pow(0.98, Math.max(0, this.computedAccuracy.n50 - objectCount / 500));
+    }
+    /**
+     * Calculates the accuracy performance value of the beatmap.
+     */
+    calculateAccuracyValue() {
+        if (this.stars.mods.some((m) => m instanceof osu_base_1.ModRelax)) {
+            return;
+        }
+        // Global variables
+        const ncircles = this.stars.mods.some((m) => m instanceof osu_base_1.ModScoreV2)
+            ? this.stars.objects.length - this.stars.map.spinners
+            : this.stars.map.circles;
+        if (ncircles === 0) {
+            return;
+        }
+        const realAccuracy = new osu_base_1.Accuracy({
+            ...this.computedAccuracy,
+            n300: this.computedAccuracy.n300 -
+                (this.stars.objects.length - ncircles),
+        });
+        // Lots of arbitrary values from testing.
+        // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
+        this.accuracy =
+            Math.pow(1.4, this.mapStatistics.od) *
+                Math.pow(realAccuracy.value(ncircles), 12) *
+                10;
+        // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
+        this.accuracy *= Math.min(1.15, Math.pow(ncircles / 1000, 0.3));
+        // Scale the accuracy value with rhythm complexity.
+        this.accuracy *= Math.min(1, Math.pow(Math.exp(this.aggregatedRhythmMultiplier - 0.5), 0.85) / 2);
+        if (this.stars.mods.some((m) => m instanceof osu_base_1.ModHidden)) {
+            this.accuracy *= 1.08;
+        }
+        if (this.stars.mods.some((m) => m instanceof osu_base_1.ModFlashlight)) {
+            this.accuracy *= 1.02;
+        }
+    }
+    /**
+     * Calculates the flashlight performance value of the beatmap.
+     */
+    calculateFlashlightValue() {
+        if (!this.stars.mods.some((m) => m instanceof osu_base_1.ModFlashlight)) {
+            return;
+        }
+        // Global variables
+        const objectCount = this.stars.objects.length;
+        this.flashlight =
+            Math.pow(Math.pow(this.stars.flashlight, 0.8), 2) * 25;
+        // Add an additional bonus for HDFL.
+        if (this.stars.mods.some((m) => m instanceof osu_base_1.ModHidden)) {
+            this.flashlight *= 1.3;
+        }
+        // Combo scaling
+        this.flashlight *= this.comboPenalty;
+        if (this.effectiveMissCount > 0) {
+            // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
+            this.flashlight *=
+                0.97 *
+                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), Math.pow(this.effectiveMissCount, 0.875));
+        }
+        // Account for shorter maps having a higher ratio of 0 combo/100 combo flashlight radius.
+        this.flashlight *=
+            0.7 +
+                0.1 * Math.min(1, objectCount / 200) +
+                (objectCount > 200
+                    ? 0.2 * Math.min(1, (objectCount - 200) / 200)
+                    : 0);
+        // Scale the flashlight value with accuracy slightly.
+        this.flashlight *= 0.5 + this.computedAccuracy.value(objectCount) / 2;
+        // It is also important to consider accuracy difficulty when doing that.
+        const odScaling = Math.pow(this.mapStatistics.od, 2) / 2500;
+        this.flashlight *=
+            0.98 + (this.mapStatistics.od >= 0 ? odScaling : -odScaling);
+    }
+    toString() {
+        return (this.total.toFixed(2) +
+            " pp (" +
+            this.aim.toFixed(2) +
+            " aim, " +
+            this.tap.toFixed(2) +
+            " tap, " +
+            this.accuracy.toFixed(2) +
+            " acc, " +
+            this.flashlight.toFixed(2) +
+            " flashlight)");
+    }
+}
+exports.DroidPerformanceCalculator = DroidPerformanceCalculator;

package/dist/DroidStarRating.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DroidStarRating = void 0;
+const DroidAim_1 = require("./skills/DroidAim");
+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");
+/**
+ * Difficulty calculator for osu!droid gamemode.
+ */
+class DroidStarRating extends StarRating_1.StarRating {
+    constructor() {
+        super(...arguments);
+        /**
+         * The aim star rating of the beatmap.
+         */
+        this.aim = 0;
+        /**
+         * The tap star rating of the beatmap.
+         */
+        this.tap = 0;
+        /**
+         * The flashlight star rating of the beatmap.
+         */
+        this.flashlight = 0;
+        this.difficultyMultiplier = 0.18;
+    }
+    /**
+     * Calculates the star rating of the specified beatmap.
+     *
+     * The beatmap is analyzed in chunks of `sectionLength` duration.
+     * For each chunk the highest hitobject strains are added to
+     * a list which is then collapsed into a weighted sum, much
+     * like scores are weighted on a user's profile.
+     *
+     * For subsequent chunks, the initial max strain is calculated
+     * by decaying the previous hitobject's strain until the
+     * beginning of the new chunk.
+     *
+     * The first object doesn't generate a strain
+     * so we begin calculating from the second object.
+     *
+     * Also don't forget to manually add the peak strain for the last
+     * section which would otherwise be ignored.
+     */
+    calculate(params) {
+        return super.calculate(params, osu_base_1.modes.droid);
+    }
+    /**
+     * Calculates the aim star rating of the beatmap and stores it in this instance.
+     */
+    calculateAim() {
+        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;
+        }
+    }
+    /**
+     * 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);
+        }
+    }
+    /**
+     * Calculates the flashlight star rating of the beatmap and stores it in this instance.
+     */
+    calculateFlashlight() {
+        const flashlightSkill = new DroidFlashlight_1.DroidFlashlight(this.mods);
+        this.calculateSkills(flashlightSkill);
+        this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
+        this.flashlight = this.starValue(flashlightSkill.difficultyValue());
+    }
+    calculateTotal() {
+        const aimPerformanceValue = this.basePerformanceValue(this.aim);
+        const speedPerformanceValue = 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(flashlightPerformanceValue, 1.1), 1 / 1.1);
+        if (basePerformanceValue > 1e-5) {
+            this.total =
+                Math.cbrt(1.12) *
+                    0.027 *
+                    (Math.cbrt((100000 / Math.pow(2, 1 / 1.1)) * basePerformanceValue) +
+                        4);
+        }
+    }
+    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];
+        }
+        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);
+            }
+        }
+        this.strainPeaks.flashlight = flashlightSkill.strainPeaks;
+        this.flashlight = this.starValue(flashlightSkill.difficultyValue());
+        this.calculateTotal();
+    }
+    /**
+     * Returns a string representative of the class.
+     */
+    toString() {
+        return (this.total.toFixed(2) +
+            " stars (" +
+            this.aim.toFixed(2) +
+            " aim, " +
+            this.tap.toFixed(2) +
+            " tap, " +
+            this.flashlight.toFixed(2) +
+            " flashlight)");
+    }
+    /**
+     * Creates skills to be calculated.
+     */
+    createSkills() {
+        return [
+            new DroidAim_1.DroidAim(this.mods, true),
+            new DroidAim_1.DroidAim(this.mods, false),
+            new DroidTap_1.DroidTap(this.mods, this.stats.od),
+            new DroidFlashlight_1.DroidFlashlight(this.mods),
+        ];
+    }
+}
+exports.DroidStarRating = DroidStarRating;

package/dist/MapStars.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapStars = void 0;
+const osu_base_1 = require("@rian8337/osu-base");
+const DroidStarRating_1 = require("./DroidStarRating");
+const OsuStarRating_1 = require("./OsuStarRating");
+/**
+ * A star rating calculator that configures which mode to calculate difficulty for and what mods are applied.
+ */
+class MapStars {
+    constructor() {
+        /**
+         * The osu!droid star rating of the beatmap.
+         */
+        this.droidStars = new DroidStarRating_1.DroidStarRating();
+        /**
+         * The osu!standard star rating of the beatmap.
+         */
+        this.pcStars = new OsuStarRating_1.OsuStarRating();
+    }
+    /**
+     * Calculates the star rating of a beatmap.
+     */
+    calculate(params) {
+        const mod = params.mods ?? [];
+        const stats = new osu_base_1.MapStats({
+            speedMultiplier: params.stats?.speedMultiplier ?? 1,
+            isForceAR: params.stats?.isForceAR ?? false,
+            oldStatistics: params.stats?.oldStatistics ?? false,
+        });
+        this.droidStars.calculate({
+            map: params.map,
+            mods: mod,
+            stats,
+        });
+        this.pcStars.calculate({
+            map: params.map,
+            mods: mod,
+            stats,
+        });
+        return this;
+    }
+    /**
+     * Returns a string representative of the class.
+     */
+    toString() {
+        return `${this.droidStars.toString()}\n${this.pcStars.toString()}`;
+    }
+}
+exports.MapStars = MapStars;