@rian8337/osu-base 1.0.0

package/dist/utils/Accuracy.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Accuracy = void 0;
+const MathUtils_1 = require("../mathutil/MathUtils");
+/**
+ * An accuracy calculator that calculates accuracy based on given parameters.
+ */
+class Accuracy {
+    /**
+     * Calculates accuracy based on given parameters.
+     *
+     * If `percent` and `nobjects` are specified, `n300`, `n100`, and `n50` will
+     * be automatically calculated to be the closest to the given
+     * acc percent.
+     *
+     * @param values Function parameters.
+     */
+    constructor(values) {
+        this.nmiss = values.nmiss ?? 0;
+        this.n300 = values.n300 ?? -1;
+        this.n100 = values.n100 ?? 0;
+        this.n50 = values.n50 ?? 0;
+        let nobjects;
+        if (values.nobjects) {
+            let n300 = this.n300;
+            nobjects = values.nobjects;
+            let hitcount;
+            if (n300 < 0) {
+                n300 = Math.max(0, nobjects - this.n100 - this.n50 - this.nmiss);
+            }
+            hitcount = n300 + this.n100 + this.n50 + this.nmiss;
+            if (hitcount > nobjects) {
+                n300 -= Math.min(n300, hitcount - nobjects);
+            }
+            hitcount = n300 + this.n100 + this.n50 + this.nmiss;
+            if (hitcount > nobjects) {
+                this.n100 -= Math.min(this.n100, hitcount - nobjects);
+            }
+            hitcount = n300 + this.n100 + this.n50 + this.nmiss;
+            if (hitcount > nobjects) {
+                this.n50 -= Math.min(this.n50, hitcount - nobjects);
+            }
+            hitcount = n300 + this.n100 + this.n50 + this.nmiss;
+            if (hitcount > nobjects) {
+                this.nmiss -= Math.min(this.nmiss, hitcount - nobjects);
+            }
+            this.n300 = nobjects - this.n100 - this.n50 - this.nmiss;
+        }
+        if (values.percent) {
+            if (!values.nobjects) {
+                throw new TypeError("nobjects is required when specifying percent");
+            }
+            nobjects = values.nobjects;
+            const max300 = nobjects - this.nmiss;
+            const maxacc = new Accuracy({
+                n300: max300,
+                n100: 0,
+                n50: 0,
+                nmiss: this.nmiss,
+            }).value() * 100;
+            let acc_percent = values.percent;
+            acc_percent = Math.max(0, Math.min(maxacc, acc_percent));
+            // just some black magic maths from wolfram alpha
+            this.n100 = Math.round(-3 * ((acc_percent * 0.01 - 1) * nobjects + this.nmiss) * 0.5);
+            if (this.n100 > max300) {
+                // acc lower than all 100s, use 50s
+                this.n100 = 0;
+                this.n50 = Math.round(-6 *
+                    ((acc_percent * 0.01 - 1) * nobjects + this.nmiss) *
+                    0.5);
+                this.n50 = Math.min(max300, this.n50);
+            }
+            this.n300 = nobjects - this.n100 - this.n50 - this.nmiss;
+        }
+    }
+    /**
+     * Calculates the accuracy value (0.0 - 1.0).
+     *
+     * @param nobjects The amount of objects in the beatmap. If `n300` was not specified in the constructor, this is required.
+     */
+    value(nobjects) {
+        let n300 = this.n300;
+        if (n300 < 0) {
+            if (!nobjects) {
+                throw new TypeError("Either n300 or nobjects must be specified");
+            }
+            n300 = nobjects - this.n100 - this.n50 - this.nmiss;
+        }
+        else {
+            nobjects ??= n300 + this.n100 + this.n50 + this.nmiss;
+        }
+        const res = (n300 * 6 + this.n100 * 2 + this.n50) / (nobjects * 6);
+        return MathUtils_1.MathUtils.clamp(res, 0, 1);
+    }
+}
+exports.Accuracy = Accuracy;

package/dist/utils/HitWindow.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OsuHitWindow = exports.DroidHitWindow = void 0;
+class HitWindow {
+    /**
+     * @param overallDifficulty The overall difficulty of this hit window.
+     */
+    constructor(overallDifficulty) {
+        this.overallDifficulty = overallDifficulty;
+    }
+}
+/**
+ * Represents the hit window of osu!droid.
+ */
+class DroidHitWindow extends HitWindow {
+    hitWindowFor300(isPrecise) {
+        if (isPrecise) {
+            return 55 + 6 * (5 - this.overallDifficulty);
+        }
+        else {
+            return 75 + 5 * (5 - this.overallDifficulty);
+        }
+    }
+    hitWindowFor100(isPrecise) {
+        if (isPrecise) {
+            return 120 + 8 * (5 - this.overallDifficulty);
+        }
+        else {
+            return 150 + 10 * (5 - this.overallDifficulty);
+        }
+    }
+    hitWindowFor50(isPrecise) {
+        if (isPrecise) {
+            return 180 + 10 * (5 - this.overallDifficulty);
+        }
+        else {
+            return 250 + 10 * (5 - this.overallDifficulty);
+        }
+    }
+}
+exports.DroidHitWindow = DroidHitWindow;
+/**
+ * Represents the hit window of osu!standard.
+ */
+class OsuHitWindow extends HitWindow {
+    hitWindowFor300() {
+        return 80 - 6 * this.overallDifficulty;
+    }
+    hitWindowFor100() {
+        return 140 - 8 * this.overallDifficulty;
+    }
+    hitWindowFor50() {
+        return 200 - 10 * this.overallDifficulty;
+    }
+}
+exports.OsuHitWindow = OsuHitWindow;

package/dist/utils/MapStats.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapStats = void 0;
+const modes_1 = require("../constants/modes");
+const HitWindow_1 = require("../utils/HitWindow");
+const ModDoubleTime_1 = require("../mods/ModDoubleTime");
+const ModHalfTime_1 = require("../mods/ModHalfTime");
+const ModNightCore_1 = require("../mods/ModNightCore");
+const ModHardRock_1 = require("../mods/ModHardRock");
+const ModEasy_1 = require("../mods/ModEasy");
+const ModPrecise_1 = require("../mods/ModPrecise");
+const ModSmallCircle_1 = require("../mods/ModSmallCircle");
+const ModReallyEasy_1 = require("../mods/ModReallyEasy");
+const ModUtil_1 = require("./ModUtil");
+/**
+ * Holds general beatmap statistics for further modifications.
+ */
+class MapStats {
+    constructor(values = {}) {
+        /**
+         * Whether this map statistics have been calculated.
+         */
+        this.calculated = false;
+        this.cs = values.cs;
+        this.ar = values.ar;
+        this.od = values.od;
+        this.hp = values.hp;
+        this.mods = values.mods ?? [];
+        this.speedMultiplier = values.speedMultiplier ?? 1;
+        this.isForceAR = values.isForceAR ?? false;
+        this.oldStatistics = values.oldStatistics ?? false;
+    }
+    /**
+     * Calculates map statistics.
+     *
+     * This can only be called once for an instance.
+     */
+    calculate(params) {
+        if (this.calculated) {
+            return this;
+        }
+        this.calculated = true;
+        if (params?.mods) {
+            this.mods = ModUtil_1.ModUtil.pcStringToMods(params.mods);
+        }
+        if (params?.speedMultiplier) {
+            this.speedMultiplier = params.speedMultiplier;
+        }
+        if (params?.isForceAR) {
+            this.isForceAR = params.isForceAR;
+        }
+        let statisticsMultiplier = 1;
+        if (this.mods.some((m) => m instanceof ModDoubleTime_1.ModDoubleTime)) {
+            this.speedMultiplier *= 1.5;
+        }
+        if (this.mods.some((m) => m instanceof ModHalfTime_1.ModHalfTime)) {
+            this.speedMultiplier *= 0.75;
+        }
+        if (this.mods.some((m) => m instanceof ModNightCore_1.ModNightCore)) {
+            this.speedMultiplier *= 1.5;
+        }
+        if (this.mods.some((m) => m instanceof ModHardRock_1.ModHardRock)) {
+            statisticsMultiplier *= 1.4;
+        }
+        if (this.mods.some((m) => m instanceof ModEasy_1.ModEasy)) {
+            statisticsMultiplier *= 0.5;
+        }
+        switch (params?.mode ?? modes_1.modes.osu) {
+            case modes_1.modes.droid:
+                // In droid pre-1.6.8, NC speed multiplier is assumed bugged (1.39)
+                if (this.mods.some((m) => m instanceof ModNightCore_1.ModNightCore) &&
+                    this.oldStatistics) {
+                    this.speedMultiplier *= 1.39 / 1.5;
+                }
+                // CS and OD work differently in droid, therefore it
+                // needs to be computed regardless of map-changing mods
+                // and statistics multiplier
+                if (this.od !== undefined) {
+                    // apply EZ or HR to OD
+                    this.od = Math.min(this.od * statisticsMultiplier, 10);
+                    // convert original OD to droid OD
+                    const droidToMS = new HitWindow_1.DroidHitWindow(this.od).hitWindowFor300(this.mods.some((m) => m instanceof ModPrecise_1.ModPrecise)) / this.speedMultiplier;
+                    this.od = 5 - (droidToMS - 50) / 6;
+                }
+                // HR and EZ works differently in droid in terms of
+                // CS modification (even CS in itself as well)
+                //
+                // If present mods are found, they need to be removed
+                // from the bitwise enum of mods to prevent double
+                // calculation
+                if (this.cs !== undefined) {
+                    // Assume 681 is height
+                    const assumedHeight = 681;
+                    let scale = ((assumedHeight / 480) * (54.42 - this.cs * 4.48) * 2) /
+                        128 +
+                        (0.5 * (11 - 5.2450170716245195)) / 5;
+                    if (this.mods.some((m) => m instanceof ModHardRock_1.ModHardRock)) {
+                        scale -= 0.125;
+                    }
+                    if (this.mods.some((m) => m instanceof ModEasy_1.ModEasy)) {
+                        scale += 0.125;
+                    }
+                    if (this.mods.some((m) => m instanceof ModReallyEasy_1.ModReallyEasy)) {
+                        scale += 0.125;
+                    }
+                    if (this.mods.some((m) => m instanceof ModSmallCircle_1.ModSmallCircle)) {
+                        scale -= ((assumedHeight / 480) * (4 * 4.48) * 2) / 128;
+                    }
+                    const radius = (64 * scale) / ((assumedHeight * 0.85) / 384);
+                    this.cs = Math.min(5 + ((1 - radius / 32) * 5) / 0.7, 10);
+                }
+                if (this.hp !== undefined) {
+                    if (this.mods.some((m) => m instanceof ModReallyEasy_1.ModReallyEasy)) {
+                        this.hp /= 2;
+                    }
+                    this.hp = Math.min(this.hp * statisticsMultiplier, 10);
+                }
+                if (this.ar !== undefined && !this.isForceAR) {
+                    this.ar *= statisticsMultiplier;
+                    if (this.mods.some((m) => m instanceof ModReallyEasy_1.ModReallyEasy)) {
+                        if (this.mods.some((m) => m instanceof ModEasy_1.ModEasy)) {
+                            this.ar *= 2;
+                            this.ar -= 0.5;
+                        }
+                        this.ar -= 0.5;
+                        this.ar -= this.speedMultiplier - 1;
+                    }
+                    this.ar = MapStats.modifyAR(this.ar, this.speedMultiplier, 1);
+                }
+                break;
+            case modes_1.modes.osu:
+                if (!this.mods.some((m) => ModUtil_1.ModUtil.mapChangingMods.find((mod) => mod.acronym === m.acronym)) &&
+                    this.speedMultiplier === 1) {
+                    break;
+                }
+                if (this.cs !== undefined) {
+                    if (this.mods.some((m) => m instanceof ModHardRock_1.ModHardRock)) {
+                        this.cs *= 1.3;
+                    }
+                    if (this.mods.some((m) => m instanceof ModEasy_1.ModEasy)) {
+                        this.cs *= 0.5;
+                    }
+                    this.cs = Math.min(this.cs, 10);
+                }
+                if (this.hp !== undefined) {
+                    this.hp = Math.min(this.hp * statisticsMultiplier, 10);
+                }
+                if (this.ar !== undefined && !this.isForceAR) {
+                    this.ar = MapStats.modifyAR(this.ar, this.speedMultiplier, statisticsMultiplier);
+                }
+                if (this.od !== undefined) {
+                    this.od = MapStats.modifyOD(this.od, this.speedMultiplier, statisticsMultiplier);
+                }
+                break;
+            default:
+                throw new TypeError("Mode not supported");
+        }
+        return this;
+    }
+    /**
+     * Returns a string representative of the class.
+     */
+    toString() {
+        return `CS: ${this.cs?.toFixed(2)}, AR: ${this.ar?.toFixed(2)}, OD: ${this.od?.toFixed(2)}, HP: ${this.hp?.toFixed(2)}`;
+    }
+    /**
+     * Utility function to apply speed and flat multipliers to stats where speed changes apply for AR.
+     *
+     * @param baseAR The base AR value.
+     * @param speedMultiplier The speed multiplier to calculate.
+     * @param statisticsMultiplier The statistics multiplier to calculate from map-changing nonspeed-changing mods.
+     */
+    static modifyAR(baseAR, speedMultiplier, statisticsMultiplier) {
+        let ar = baseAR;
+        ar *= statisticsMultiplier;
+        let arMS = ar < 5.0
+            ? this.AR0_MS - this.AR_MS_STEP1 * ar
+            : this.AR5_MS - this.AR_MS_STEP2 * (ar - 5);
+        arMS = Math.min(this.AR0_MS, Math.max(this.AR10_MS, arMS));
+        arMS /= speedMultiplier;
+        ar =
+            arMS > this.AR5_MS
+                ? (this.AR0_MS - arMS) / this.AR_MS_STEP1
+                : 5 + (this.AR5_MS - arMS) / this.AR_MS_STEP2;
+        return ar;
+    }
+    /**
+     * Utility function to apply speed and flat multipliers to stats where speed changes apply for OD.
+     *
+     * @param baseOD The base OD value.
+     * @param speedMultiplier The speed multiplier to calculate.
+     * @param statisticsMultiplier The statistics multiplier to calculate from map-changing nonspeed-changing mods.
+     */
+    static modifyOD(baseOD, speedMultiplier, statisticsMultiplier) {
+        let od = baseOD;
+        od *= statisticsMultiplier;
+        let odMS = this.OD0_MS - Math.ceil(this.OD_MS_STEP * od);
+        odMS = Math.min(this.OD0_MS, Math.max(this.OD10_MS, odMS));
+        odMS /= speedMultiplier;
+        od = (this.OD0_MS - odMS) / this.OD_MS_STEP;
+        return od;
+    }
+}
+exports.MapStats = MapStats;
+MapStats.OD0_MS = 80;
+MapStats.OD10_MS = 20;
+MapStats.AR0_MS = 1800;
+MapStats.AR5_MS = 1200;
+MapStats.AR10_MS = 450;
+MapStats.OD_MS_STEP = (MapStats.OD0_MS - MapStats.OD10_MS) / 10;
+MapStats.AR_MS_STEP1 = (MapStats.AR0_MS - MapStats.AR5_MS) / 5;
+MapStats.AR_MS_STEP2 = (MapStats.AR5_MS - MapStats.AR10_MS) / 5;

package/dist/utils/ModUtil.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModUtil = void 0;
+const ModAuto_1 = require("../mods/ModAuto");
+const ModAutopilot_1 = require("../mods/ModAutopilot");
+const ModDoubleTime_1 = require("../mods/ModDoubleTime");
+const ModEasy_1 = require("../mods/ModEasy");
+const ModFlashlight_1 = require("../mods/ModFlashlight");
+const ModHalfTime_1 = require("../mods/ModHalfTime");
+const ModHardRock_1 = require("../mods/ModHardRock");
+const ModHidden_1 = require("../mods/ModHidden");
+const ModNightCore_1 = require("../mods/ModNightCore");
+const ModNoFail_1 = require("../mods/ModNoFail");
+const ModPerfect_1 = require("../mods/ModPerfect");
+const ModPrecise_1 = require("../mods/ModPrecise");
+const ModReallyEasy_1 = require("../mods/ModReallyEasy");
+const ModRelax_1 = require("../mods/ModRelax");
+const ModScoreV2_1 = require("../mods/ModScoreV2");
+const ModSmallCircle_1 = require("../mods/ModSmallCircle");
+const ModSpunOut_1 = require("../mods/ModSpunOut");
+const ModSuddenDeath_1 = require("../mods/ModSuddenDeath");
+const ModTouchDevice_1 = require("../mods/ModTouchDevice");
+/**
+ * Utilities for mods.
+ */
+class ModUtil {
+    /**
+     * Gets a list of mods from a droid mod string, such as "hd".
+     *
+     * @param str The string.
+     */
+    static droidStringToMods(str) {
+        return this.checkDuplicateMods(this.allMods.filter((m) => m.droidString && str.toLowerCase().includes(m.droidString)));
+    }
+    /**
+     * Gets a list of mods from a PC modbits.
+     *
+     * @param modbits The modbits.
+     */
+    static pcModbitsToMods(modbits) {
+        return this.checkDuplicateMods(this.allMods.filter((m) => m.bitwise & modbits));
+    }
+    /**
+     * Gets a list of mods from a PC mod string, such as "HDHR".
+     *
+     * @param str The string.
+     */
+    static pcStringToMods(str) {
+        const finalMods = [];
+        str = str.toLowerCase();
+        while (str) {
+            let nchars = 1;
+            for (const mod of this.allMods) {
+                if (str.startsWith(mod.acronym.toLowerCase())) {
+                    finalMods.push(mod);
+                    nchars = 2;
+                    break;
+                }
+            }
+            str = str.slice(nchars);
+        }
+        return this.checkDuplicateMods(finalMods);
+    }
+    /**
+     * Checks for mods that are duplicate and incompatible with each other.
+     *
+     * @param mods The mods to check for.
+     */
+    static checkDuplicateMods(mods) {
+        for (const incompatibleMod of this.incompatibleMods) {
+            const fulfilledMods = mods.filter((m) => incompatibleMod.map((v) => v.acronym).includes(m.acronym));
+            if (fulfilledMods.length > 1) {
+                mods = mods.filter((m) => !incompatibleMod
+                    .map((v) => v.acronym)
+                    .includes(m.acronym));
+                // Keep the first selected mod
+                mods.push(fulfilledMods[0]);
+            }
+        }
+        // Check for duplicate mod entries
+        return Array.from(new Set(mods));
+    }
+}
+exports.ModUtil = ModUtil;
+/**
+ * Mods that are incompatible with each other.
+ */
+ModUtil.incompatibleMods = [
+    [new ModDoubleTime_1.ModDoubleTime(), new ModNightCore_1.ModNightCore(), new ModHalfTime_1.ModHalfTime()],
+    [new ModNoFail_1.ModNoFail(), new ModSuddenDeath_1.ModSuddenDeath(), new ModPerfect_1.ModPerfect()],
+    [new ModHardRock_1.ModHardRock(), new ModEasy_1.ModEasy()],
+    [new ModAuto_1.ModAuto(), new ModRelax_1.ModRelax(), new ModAutopilot_1.ModAutopilot()],
+];
+/**
+ * All mods that exists.
+ */
+ModUtil.allMods = [
+    // Janky order to keep the order on what players are used to
+    new ModAuto_1.ModAuto(),
+    new ModRelax_1.ModRelax(),
+    new ModAutopilot_1.ModAutopilot(),
+    new ModEasy_1.ModEasy(),
+    new ModNoFail_1.ModNoFail(),
+    new ModHidden_1.ModHidden(),
+    new ModHardRock_1.ModHardRock(),
+    new ModDoubleTime_1.ModDoubleTime(),
+    new ModNightCore_1.ModNightCore(),
+    new ModHalfTime_1.ModHalfTime(),
+    new ModFlashlight_1.ModFlashlight(),
+    new ModSuddenDeath_1.ModSuddenDeath(),
+    new ModPerfect_1.ModPerfect(),
+    new ModPrecise_1.ModPrecise(),
+    new ModReallyEasy_1.ModReallyEasy(),
+    new ModScoreV2_1.ModScoreV2(),
+    new ModSmallCircle_1.ModSmallCircle(),
+    new ModSpunOut_1.ModSpunOut(),
+    new ModTouchDevice_1.ModTouchDevice(),
+];
+/**
+ * Mods that change the playback speed of a beatmap.
+ */
+ModUtil.speedChangingMods = [
+    new ModDoubleTime_1.ModDoubleTime(),
+    new ModNightCore_1.ModNightCore(),
+    new ModHalfTime_1.ModHalfTime(),
+];
+/**
+ * Mods that change the way the map looks.
+ */
+ModUtil.mapChangingMods = [
+    new ModDoubleTime_1.ModDoubleTime(),
+    new ModNightCore_1.ModNightCore(),
+    new ModHalfTime_1.ModHalfTime(),
+    new ModEasy_1.ModEasy(),
+    new ModHardRock_1.ModHardRock(),
+    new ModSmallCircle_1.ModSmallCircle(),
+];