@rian8337/osu-difficulty-calculator 1.0.0

package/dist/OsuPerformanceCalculator.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OsuPerformanceCalculator = void 0;
+const OsuStarRating_1 = require("./OsuStarRating");
+const PerformanceCalculator_1 = require("./base/PerformanceCalculator");
+const osu_base_1 = require("@rian8337/osu-base");
+/**
+ * A performance points calculator that calculates performance points for osu!standard gamemode.
+ */
+class OsuPerformanceCalculator extends PerformanceCalculator_1.PerformanceCalculator {
+    constructor() {
+        super(...arguments);
+        this.stars = new OsuStarRating_1.OsuStarRating();
+        this.finalMultiplier = 1.12;
+        /**
+         * The aim performance value.
+         */
+        this.aim = 0;
+        /**
+         * The speed performance value.
+         */
+        this.speed = 0;
+        /**
+         * The accuracy performance value.
+         */
+        this.accuracy = 0;
+        /**
+         * The flashlight performance value.
+         */
+        this.flashlight = 0;
+    }
+    calculate(params) {
+        this.handleParams(params, osu_base_1.modes.osu);
+        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;
+    }
+    /**
+     * 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, this.stars.mods.some((m) => m instanceof osu_base_1.ModTouchDevice)
+            ? 0.8
+            : 1));
+        // Longer maps are worth more
+        let lengthBonus = 0.95 + 0.4 * Math.min(1, objectCount / 2000);
+        if (objectCount > 2000) {
+            lengthBonus += Math.log10(objectCount / 2000) * 0.5;
+        }
+        this.aim *= lengthBonus;
+        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;
+        // 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 * 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 *= hiddenBonus;
+        // 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 + odScaling;
+    }
+    /**
+     * Calculates the speed performance value of the beatmap.
+     */
+    calculateSpeedValue() {
+        // Global variables
+        const objectCount = this.stars.objects.length;
+        const calculatedAR = this.mapStatistics.ar;
+        const n50 = this.computedAccuracy.n50;
+        this.speed = this.baseValue(this.stars.speed);
+        // Longer maps are worth more
+        let lengthBonus = 0.95 + 0.4 * Math.min(1, objectCount / 2000);
+        if (objectCount > 2000) {
+            lengthBonus += Math.log10(objectCount / 2000) * 0.5;
+        }
+        this.speed *= lengthBonus;
+        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.speed *=
+                0.97 *
+                    Math.pow(1 - Math.pow(this.effectiveMissCount / objectCount, 0.775), Math.pow(this.effectiveMissCount, 0.875));
+        }
+        // Combo scaling
+        this.speed *= this.comboPenalty;
+        // AR scaling
+        if (calculatedAR > 10.33) {
+            // Buff for longer maps with high AR.
+            this.speed *= 1 + 0.3 * (calculatedAR - 10.33) * lengthBonus;
+        }
+        if (this.stars.mods.some((m) => m instanceof osu_base_1.ModHidden)) {
+            this.speed *= 1 + 0.04 * (12 - calculatedAR);
+        }
+        // Scale the speed value with accuracy and OD.
+        this.speed *=
+            (0.95 + Math.pow(this.mapStatistics.od, 2) / 750) *
+                Math.pow(this.computedAccuracy.value(objectCount), (14.5 - Math.max(this.mapStatistics.od, 8)) / 2);
+        // Scale the speed value with # of 50s to punish doubletapping.
+        this.speed *= Math.pow(0.98, Math.max(0, 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 nobjects = this.stars.objects.length;
+        const ncircles = this.stars.mods.some((m) => m instanceof osu_base_1.ModScoreV2)
+            ? nobjects - 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.52163, this.mapStatistics.od) *
+                Math.pow(realAccuracy.value(ncircles), 24) *
+                2.83;
+        // 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));
+        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, this.stars.mods.some((m) => m instanceof osu_base_1.ModTouchDevice)
+                ? 0.8
+                : 1), 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 + odScaling;
+    }
+    toString() {
+        return (this.total.toFixed(2) +
+            " pp (" +
+            this.aim.toFixed(2) +
+            " aim, " +
+            this.speed.toFixed(2) +
+            " speed, " +
+            this.accuracy.toFixed(2) +
+            " acc, " +
+            this.flashlight.toFixed(2) +
+            " flashlight)");
+    }
+}
+exports.OsuPerformanceCalculator = OsuPerformanceCalculator;

package/dist/OsuStarRating.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OsuStarRating = void 0;
+const OsuAim_1 = require("./skills/OsuAim");
+const OsuSpeed_1 = require("./skills/OsuSpeed");
+const StarRating_1 = require("./base/StarRating");
+const OsuFlashlight_1 = require("./skills/OsuFlashlight");
+const osu_base_1 = require("@rian8337/osu-base");
+/**
+ * Difficulty calculator for osu!standard gamemode.
+ */
+class OsuStarRating extends StarRating_1.StarRating {
+    constructor() {
+        super(...arguments);
+        /**
+         * The aim star rating of the beatmap.
+         */
+        this.aim = 0;
+        /**
+         * The speed star rating of the beatmap.
+         */
+        this.speed = 0;
+        /**
+         * The flashlight star rating of the beatmap.
+         */
+        this.flashlight = 0;
+        this.difficultyMultiplier = 0.0675;
+    }
+    calculate(params) {
+        return super.calculate(params, osu_base_1.modes.osu);
+    }
+    /**
+     * Calculates the aim star rating of the beatmap and stores it in this instance.
+     */
+    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;
+        }
+    }
+    /**
+     * Calculates the speed star rating of the beatmap and stores it in this instance.
+     */
+    calculateSpeed() {
+        if (this.mods.some((m) => m instanceof osu_base_1.ModRelax)) {
+            return;
+        }
+        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());
+    }
+    /**
+     * Calculates the flashlight star rating of the beatmap and stores it in this instance.
+     */
+    calculateFlashlight() {
+        const flashlightSkill = new OsuFlashlight_1.OsuFlashlight(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.speed);
+        let flashlightPerformanceValue = 0;
+        if (this.mods.some((m) => m instanceof osu_base_1.ModFlashlight)) {
+            flashlightPerformanceValue = Math.pow(this.flashlight, 2) * 25;
+        }
+        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 speedSkill;
+        let flashlightSkill;
+        if (isRelax) {
+            flashlightSkill = skills[2];
+        }
+        else {
+            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;
+        }
+        if (speedSkill) {
+            this.strainPeaks.speed = speedSkill.strainPeaks;
+            this.speed = this.starValue(speedSkill.difficultyValue());
+        }
+        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.speed.toFixed(2) +
+            " speed, " +
+            this.flashlight.toFixed(2) +
+            " flashlight)");
+    }
+    /**
+     * Creates skills to be calculated.
+     */
+    createSkills() {
+        return [
+            new OsuAim_1.OsuAim(this.mods, true),
+            new OsuAim_1.OsuAim(this.mods, false),
+            new OsuSpeed_1.OsuSpeed(this.mods, new osu_base_1.OsuHitWindow(this.stats.od).hitWindowFor300()),
+            new OsuFlashlight_1.OsuFlashlight(this.mods),
+        ];
+    }
+}
+exports.OsuStarRating = OsuStarRating;

package/dist/base/DifficultyAttributes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/base/PerformanceCalculator.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceCalculator = void 0;
+const osu_base_1 = require("@rian8337/osu-base");
+/**
+ * The base class of performance calculators.
+ */
+class PerformanceCalculator {
+    constructor() {
+        /**
+         * The overall performance value.
+         */
+        this.total = 0;
+        /**
+         * The calculated accuracy.
+         */
+        this.computedAccuracy = new osu_base_1.Accuracy({});
+        /**
+         * The map statistics after applying modifications.
+         */
+        this.mapStatistics = new osu_base_1.MapStats();
+        /**
+         * Penalty for combo breaks.
+         */
+        this.comboPenalty = 0;
+        /**
+         * The amount of misses that are filtered out from sliderbreaks.
+         */
+        this.effectiveMissCount = 0;
+        /**
+         * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
+         */
+        this.sliderNerfFactor = 1;
+    }
+    /**
+     * Calculates the base performance value for of a star rating.
+     */
+    baseValue(stars) {
+        return Math.pow(5 * Math.max(1, stars / 0.0675) - 4, 3) / 100000;
+    }
+    /**
+     * Processes given parameters for usage in performance calculation.
+     */
+    handleParams(params, mode) {
+        this.stars = params.stars;
+        const maxCombo = this.stars.map.maxCombo;
+        const miss = this.computedAccuracy.nmiss;
+        const combo = params.combo ?? maxCombo - miss;
+        const mod = this.stars.mods;
+        const baseAR = this.stars.map.ar;
+        const baseOD = this.stars.map.od;
+        // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
+        this.comboPenalty = Math.min(Math.pow(combo / maxCombo, 0.8), 1);
+        if (params.accPercent instanceof osu_base_1.Accuracy) {
+            // Copy into new instance to not modify the original
+            this.computedAccuracy = new osu_base_1.Accuracy(params.accPercent);
+        }
+        else {
+            this.computedAccuracy = new osu_base_1.Accuracy({
+                percent: params.accPercent,
+                nobjects: this.stars.objects.length,
+                nmiss: params.miss || 0,
+            });
+        }
+        if (this.stars.mods.some((m) => m instanceof osu_base_1.ModNoFail)) {
+            this.finalMultiplier *= Math.max(0.9, 1 - 0.02 * this.computedAccuracy.nmiss);
+        }
+        if (this.stars.mods.some((m) => m instanceof osu_base_1.ModSpunOut)) {
+            this.finalMultiplier *=
+                1 -
+                    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;
+            this.finalMultiplier *= 0.6;
+        }
+        this.effectiveMissCount = this.calculateEffectiveMissCount(combo, maxCombo);
+        this.mapStatistics = new osu_base_1.MapStats({
+            ar: baseAR,
+            od: baseOD,
+            mods: mod,
+        });
+        // We assume 15% of sliders in a beatmap are difficult since there's no way to tell from the performance calculator.
+        const estimateDifficultSliders = this.stars.map.sliders * 0.15;
+        const estimateSliderEndsDropped = osu_base_1.MathUtils.clamp(Math.min(this.computedAccuracy.n300 +
+            this.computedAccuracy.n50 +
+            this.computedAccuracy.nmiss, maxCombo - combo), 0, estimateDifficultSliders);
+        if (this.stars.map.sliders > 0) {
+            this.sliderNerfFactor =
+                (1 - this.stars.attributes.sliderFactor) *
+                    Math.pow(1 -
+                        estimateSliderEndsDropped /
+                            estimateDifficultSliders, 3) +
+                    this.stars.attributes.sliderFactor;
+        }
+        if (params.stats) {
+            this.mapStatistics.ar = params.stats.ar ?? this.mapStatistics.ar;
+            this.mapStatistics.isForceAR =
+                params.stats.isForceAR ?? this.mapStatistics.isForceAR;
+            this.mapStatistics.speedMultiplier =
+                params.stats.speedMultiplier ??
+                    this.mapStatistics.speedMultiplier;
+            this.mapStatistics.oldStatistics =
+                params.stats.oldStatistics ?? this.mapStatistics.oldStatistics;
+        }
+        this.mapStatistics.calculate({ mode: mode });
+    }
+    /**
+     * Calculates the amount of misses + sliderbreaks from combo.
+     */
+    calculateEffectiveMissCount(combo, maxCombo) {
+        let comboBasedMissCount = 0;
+        if (this.stars.map.sliders > 0) {
+            const fullComboThreshold = maxCombo - 0.1 * this.stars.map.sliders;
+            if (combo < fullComboThreshold) {
+                // We're clamping miss count because since it's derived from combo, it can
+                // be higher than the amount of objects and that breaks some calculations.
+                comboBasedMissCount = Math.min(fullComboThreshold / Math.max(1, combo), this.stars.objects.length);
+            }
+        }
+        return Math.max(this.computedAccuracy.nmiss, Math.floor(comboBasedMissCount));
+    }
+}
+exports.PerformanceCalculator = PerformanceCalculator;

package/dist/base/Skill.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Skill = void 0;
+/**
+ * A bare minimal abstract skill for fully custom skill implementations.
+ */
+class Skill {
+    constructor(mods) {
+        /**
+         * The hitobjects that were processed previously. They can affect the strain values of the following objects.
+         *
+         * The latest hitobject is at index 0.
+         */
+        this.previous = [];
+        /**
+         * Number of previous hitobjects to keep inside the `previous` array.
+         */
+        this.historyLength = 2;
+        this.mods = mods;
+    }
+    processInternal(current) {
+        while (this.previous.length > this.historyLength) {
+            this.previous.pop();
+        }
+        this.process(current);
+        this.previous.unshift(current);
+    }
+}
+exports.Skill = Skill;

package/dist/base/StarRating.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarRating = void 0;
+const osu_base_1 = require("@rian8337/osu-base");
+const DifficultyHitObjectCreator_1 = require("../preprocessing/DifficultyHitObjectCreator");
+/**
+ * The base of difficulty calculation.
+ */
+class StarRating {
+    constructor() {
+        /**
+         * The calculated beatmap.
+         */
+        this.map = new osu_base_1.Beatmap();
+        /**
+         * The difficulty objects of the beatmap.
+         */
+        this.objects = [];
+        /**
+         * The modifications applied.
+         */
+        this.mods = [];
+        /**
+         * The total star rating of the beatmap.
+         */
+        this.total = 0;
+        /**
+         * The map statistics of the beatmap after modifications are applied.
+         */
+        this.stats = new osu_base_1.MapStats();
+        /**
+         * The strain peaks of various calculated difficulties.
+         */
+        this.strainPeaks = {
+            aimWithSliders: [],
+            aimWithoutSliders: [],
+            speed: [],
+            flashlight: [],
+        };
+        /**
+         * Additional data that is used in performance calculation.
+         */
+        this.attributes = {
+            speedNoteCount: 0,
+            sliderFactor: 1,
+        };
+        this.sectionLength = 400;
+    }
+    /**
+     * 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, mode) {
+        const map = (this.map = osu_base_1.Utils.deepCopy(params.map));
+        const mod = (this.mods = params.mods ?? this.mods);
+        this.stats = new osu_base_1.MapStats({
+            cs: map.cs,
+            ar: map.ar,
+            od: map.od,
+            hp: map.hp,
+            mods: mod,
+            speedMultiplier: params.stats?.speedMultiplier ?? 1,
+            oldStatistics: params.stats?.oldStatistics ?? false,
+        }).calculate({ mode: mode });
+        this.generateDifficultyHitObjects(mode);
+        this.calculateAll();
+        return this;
+    }
+    /**
+     * Generates difficulty hitobjects for this calculator.
+     *
+     * @param mode The gamemode to generate difficulty hitobjects for.
+     */
+    generateDifficultyHitObjects(mode) {
+        this.objects.length = 0;
+        this.objects.push(...new DifficultyHitObjectCreator_1.DifficultyHitObjectCreator().generateDifficultyObjects({
+            objects: this.map.objects,
+            circleSize: this.stats.cs,
+            speedMultiplier: this.stats.speedMultiplier,
+            mode: mode,
+        }));
+    }
+    /**
+     * Calculates the skills provided.
+     *
+     * @param skills The skills to calculate.
+     */
+    calculateSkills(...skills) {
+        this.objects.slice(1).forEach((h, i) => {
+            skills.forEach((skill) => {
+                skill.processInternal(h);
+                if (i === this.objects.length - 2) {
+                    // Don't forget to save the last strain peak, which would otherwise be ignored.
+                    skill.saveCurrentPeak();
+                }
+            });
+        });
+    }
+    /**
+     * Calculates the star rating value of a difficulty.
+     *
+     * @param difficulty The difficulty to calculate.
+     */
+    starValue(difficulty) {
+        return Math.sqrt(difficulty) * this.difficultyMultiplier;
+    }
+    /**
+     * Calculates the base performance value of a difficulty rating.
+     *
+     * @param rating The difficulty rating.
+     */
+    basePerformanceValue(rating) {
+        return Math.pow(5 * Math.max(1, rating / 0.0675) - 4, 3) / 100000;
+    }
+}
+exports.StarRating = StarRating;