@rian8337/osu-base 2.0.0-alpha.6 → 2.0.0

package/dist/index.js

@@ -815,9 +815,7 @@ class Slider extends HitObject {
             startTime: finalSpanEndTime,
         });
         this.nestedHitObjects.push(this.tail);
-        this.nestedHitObjects.sort((a, b) => {
-            return a.startTime - b.startTime;
-        });
+        this.nestedHitObjects.sort((a, b) => a.startTime - b.startTime);
     }
     toString() {
         return `Position: [${this.position.x}, ${this.position.y}], distance: ${this.path.expectedDistance}, repetitions: ${this.repetitions}, slider ticks: ${this.nestedHitObjects.filter((v) => v instanceof SliderTick).length}`;
@@ -1196,6 +1194,8 @@ class ControlPointManager {
     /**
      * Removes a control point.
      *
+     * This method will remove the earliest control point in the array that is equal to the given control point.
+     *
      * @param controlPoint The control point to remove.
      * @returns Whether the control point was removed.
      */
@@ -1872,6 +1872,51 @@ class HitWindow {
  * Represents the hit window of osu!droid.
  */
 class DroidHitWindow extends HitWindow {
+    /**
+     * Calculates the overall difficulty value of a great hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @param isPrecise Whether to calculate for Precise mod.
+     * @returns The overall difficulty value.
+     */
+    static hitWindow300ToOD(value, isPrecise) {
+        if (isPrecise) {
+            return 5 - (value - 55) / 6;
+        }
+        else {
+            return 5 - (value - 75) / 5;
+        }
+    }
+    /**
+     * Calculates the overall difficulty value of a good hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @param isPrecise Whether to calculate for Precise mod.
+     * @returns The overall difficulty value.
+     */
+    static hitWindow100ToOD(value, isPrecise) {
+        if (isPrecise) {
+            return 5 - (value - 120) / 8;
+        }
+        else {
+            return 5 - (value - 150) / 10;
+        }
+    }
+    /**
+     * Calculates the overall difficulty value of a meh hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @param isPrecise Whether to calculate for Precise mod.
+     * @returns The overall difficulty value.
+     */
+    static hitWindow50ToOD(value, isPrecise) {
+        if (isPrecise) {
+            return 5 - (value - 180) / 10;
+        }
+        else {
+            return 5 - (value - 250) / 10;
+        }
+    }
     hitWindowFor300(isPrecise) {
         if (isPrecise) {
             return 55 + 6 * (5 - this.overallDifficulty);
@@ -1901,6 +1946,33 @@ class DroidHitWindow extends HitWindow {
  * Represents the hit window of osu!standard.
  */
 class OsuHitWindow extends HitWindow {
+    /**
+     * Calculates the overall difficulty value of a great hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @returns The overall difficulty value.
+     */
+    static hitWindow300ToOD(value) {
+        return (80 - value) / 6;
+    }
+    /**
+     * Calculates the overall difficulty value of a good hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @returns The overall difficulty value.
+     */
+    static hitWindow100ToOD(value) {
+        return (140 - value) / 8;
+    }
+    /**
+     * Calculates the overall difficulty value of a meh hit window.
+     *
+     * @param value The value of the hit window, in milliseconds.
+     * @returns The overall difficulty value.
+     */
+    static hitWindow50ToOD(value) {
+        return (200 - value) / 10;
+    }
     hitWindowFor300() {
         return 80 - 6 * this.overallDifficulty;
     }
@@ -2076,6 +2148,8 @@ class ModFlashlight extends Mod {
  * Represents the Hidden mod.
  */
 class ModHidden extends Mod {
+    static fadeInDurationMultiplier = 0.4;
+    static fadeOutDurationMultiplier = 0.3;
     scoreMultiplier = 1.06;
     acronym = "HD";
     name = "Hidden";
@@ -2234,9 +2308,7 @@ class ModUtil {
      * Mods that change the way the map looks.
      */
     static mapChangingMods = [
-        new ModDoubleTime(),
-        new ModNightCore(),
-        new ModHalfTime(),
+        ...this.speedChangingMods,
         new ModEasy(),
         new ModHardRock(),
         new ModSmallCircle(),
@@ -2245,24 +2317,27 @@ class ModUtil {
      * Gets a list of mods from a droid mod string, such as "hd".
      *
      * @param str The string.
+     * @param options Options for parsing behavior.
      */
-    static droidStringToMods(str) {
-        return this.checkDuplicateMods(this.allMods.filter((m) => m.droidString && str.toLowerCase().includes(m.droidString)));
+    static droidStringToMods(str, options) {
+        return this.processParsingOptions(this.allMods.filter((m) => m.droidString && str.toLowerCase().includes(m.droidString)), options);
     }
     /**
      * Gets a list of mods from a PC modbits.
      *
      * @param modbits The modbits.
+     * @param options Options for parsing behavior.
      */
-    static pcModbitsToMods(modbits) {
-        return this.checkDuplicateMods(this.allMods.filter((m) => m.bitwise & modbits));
+    static pcModbitsToMods(modbits, options) {
+        return this.processParsingOptions(this.allMods.filter((m) => m.bitwise & modbits), options);
     }
     /**
      * Gets a list of mods from a PC mod string, such as "HDHR".
      *
      * @param str The string.
+     * @param options Options for parsing behavior.
      */
-    static pcStringToMods(str) {
+    static pcStringToMods(str, options) {
         const finalMods = [];
         str = str.toLowerCase();
         while (str) {
@@ -2276,14 +2351,25 @@ class ModUtil {
             }
             str = str.slice(nchars);
         }
-        return this.checkDuplicateMods(finalMods);
+        return this.processParsingOptions(finalMods, options);
     }
     /**
-     * Checks for mods that are duplicate and incompatible with each other.
+     * Checks for mods that are duplicated.
      *
      * @param mods The mods to check for.
+     * @returns Mods that have been filtered.
      */
     static checkDuplicateMods(mods) {
+        return Array.from(new Set(mods));
+    }
+    /**
+     * Checks for mods that are incompatible with each other.
+     *
+     * This will modify the original array.
+     *
+     * @param mods The mods to check for.
+     */
+    static checkIncompatibleMods(mods) {
         for (const incompatibleMod of this.incompatibleMods) {
             const fulfilledMods = mods.filter((m) => incompatibleMod.map((v) => v.acronym).includes(m.acronym));
             if (fulfilledMods.length > 1) {
@@ -2294,8 +2380,22 @@ class ModUtil {
                 mods.push(fulfilledMods[0]);
             }
         }
-        // Check for duplicate mod entries
-        return Array.from(new Set(mods));
+    }
+    /**
+     * Processes parsing options.
+     *
+     * @param mods The mods to process.
+     * @param options The options to process.
+     * @returns The processed mods.
+     */
+    static processParsingOptions(mods, options) {
+        if (options?.checkDuplicate !== false) {
+            mods = this.checkDuplicateMods(mods);
+        }
+        if (options?.checkIncompatible !== false) {
+            this.checkIncompatibleMods(mods);
+        }
+        return mods;
     }
 }
 
@@ -2394,29 +2494,31 @@ class MapStats {
         }
         switch (params?.mode ?? exports.modes.osu) {
             case exports.modes.droid:
-                // In droid pre-1.6.8, NC speed multiplier is assumed bugged (1.39)
+                // In droid pre-1.6.8, NC speed multiplier is assumed bugged (1.39).
                 if (this.mods.some((m) => m instanceof 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
+                // and statistics multiplier.
                 if (this.od !== undefined) {
-                    // apply EZ or HR to OD
+                    // Apply EZ or HR to OD.
                     this.od = Math.min(this.od * statisticsMultiplier, 10);
-                    // convert original OD to droid OD
+                    // Convert original OD to droid hit window to take
+                    // droid hit window and the PR mod in mind.
                     const droidToMS = new DroidHitWindow(this.od).hitWindowFor300(this.mods.some((m) => m instanceof ModPrecise)) / this.speedMultiplier;
-                    this.od = 5 - (droidToMS - 50) / 6;
+                    // Convert droid hit window back to original OD.
+                    this.od = OsuHitWindow.hitWindow300ToOD(droidToMS);
                 }
                 // HR and EZ works differently in droid in terms of
-                // CS modification (even CS in itself as well)
+                // 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
+                // calculation.
                 if (this.cs !== undefined) {
-                    // Assume 681 is height
+                    // Assume 681 is height.
                     const assumedHeight = 681;
                     let scale = ((assumedHeight / 480) * (54.42 - this.cs * 4.48) * 2) /
                         128 +
@@ -2433,7 +2535,8 @@ class MapStats {
                     if (this.mods.some((m) => m instanceof ModSmallCircle)) {
                         scale -= ((assumedHeight / 480) * (4 * 4.48) * 2) / 128;
                     }
-                    const radius = (64 * scale) / ((assumedHeight * 0.85) / 384);
+                    const radius = (64 * Math.max(1e-3, scale)) /
+                        ((assumedHeight * 0.85) / 384);
                     this.cs = Math.min(5 + ((1 - radius / 32) * 5) / 0.7, 10);
                 }
                 if (this.hp !== undefined) {
@@ -5226,6 +5329,15 @@ class Encoder {
      * The result of the encoding process.
      */
     finalResult = "";
+    /**
+     * The result of the encoding process.
+     */
+    get result() {
+        return this.finalResult;
+    }
+    /**
+     * @param target The target of the encoding process.
+     */
     constructor(target) {
         this.target = target;
     }
@@ -5237,7 +5349,7 @@ class Encoder {
     encode() {
         this.reset();
         this.encodeInternal();
-        return this.finalResult;
+        return this;
     }
     /**
      * Writes a line to encoded text.
@@ -5670,6 +5782,12 @@ class StoryboardVariablesEncoder extends StoryboardBaseEncoder {
     }
 }
 
+/**
+ * A storyboard encoder.
+ *
+ * Note that this storyboard encoder does not encode storyboards, and as such equality with the
+ * original beatmap or storyboard file is not guaranteed (and usually will not be equal).
+ */
 class StoryboardEncoder extends Encoder {
     finalResult = "";
     encoders = [];
@@ -5709,7 +5827,7 @@ class BeatmapEventsEncoder extends BeatmapBaseEncoder {
             this.writeLine(`2,${b.startTime},${b.endTime}`);
         }
         if (this.map.events.storyboard) {
-            this.writeLine(new StoryboardEncoder(this.map.events.storyboard, false).encode());
+            this.writeLine(new StoryboardEncoder(this.map.events.storyboard, false).encode().result);
         }
         else {
             this.writeLine("//Storyboard Layer 0 (Background)");
@@ -6125,31 +6243,16 @@ class MapInfo {
      */
     videoAvailable = false;
     /**
-     * The parsed beatmap from beatmap parser.
+     * The decoded beatmap from beatmap decoder.
      */
-    get map() {
-        return Utils.deepCopy(this.cachedBeatmap);
+    get beatmap() {
+        return this.cachedBeatmap;
     }
-    cachedBeatmap;
-    /**
-     * Retrieve a beatmap's general information.
-     *
-     * Either beatmap ID or MD5 hash of the beatmap must be specified. If both are specified, beatmap ID is taken.
-     */
-    static async getInformation(params) {
-        params.file ??= true;
-        const beatmapID = params.beatmapID;
-        const hash = params.hash;
-        if (!beatmapID && !hash) {
-            throw new Error("Beatmap ID or MD5 hash must be defined");
-        }
-        const apiRequestBuilder = new OsuAPIRequestBuilder().setEndpoint("get_beatmaps");
-        if (beatmapID) {
-            apiRequestBuilder.addParameter("b", beatmapID);
-        }
-        else if (hash) {
-            apiRequestBuilder.addParameter("h", hash);
-        }
+    cachedBeatmap = null;
+    static async getInformation(beatmapIdOrHash, downloadBeatmap) {
+        const apiRequestBuilder = new OsuAPIRequestBuilder()
+            .setEndpoint("get_beatmaps")
+            .addParameter(typeof beatmapIdOrHash === "string" ? "h" : "b", beatmapIdOrHash);
         const map = new MapInfo();
         const result = await apiRequestBuilder.sendRequest();
         if (result.statusCode !== 200) {
@@ -6157,13 +6260,13 @@ class MapInfo {
         }
         const mapinfo = JSON.parse(result.data.toString("utf-8"))[0];
         if (!mapinfo) {
-            return map;
+            return null;
         }
         if (parseInt(mapinfo.mode) !== 0) {
-            return map;
+            return null;
         }
         map.fillMetadata(mapinfo);
-        if (params.file) {
+        if (downloadBeatmap !== false) {
             await map.retrieveBeatmapFile();
         }
         return map;
@@ -6226,15 +6329,23 @@ class MapInfo {
         this.videoAvailable = !!parseInt(mapinfo.video);
         return this;
     }
+    /**
+     * Checks whether the beatmap file has been downloaded.
+     */
+    hasDownloadedBeatmap() {
+        return this.cachedBeatmap !== null;
+    }
     /**
      * Retrieves the .osu file of the beatmap.
      *
-     * @param forceDownload Whether or not to download the file regardless if it's already available.
+     * After this, you can use the `hasDownloadedBeatmap` method to check if the beatmap has been downloaded.
+     *
+     * @param force Whether to download the file regardless if it's already available.
      */
-    retrieveBeatmapFile(forceDownload) {
+    retrieveBeatmapFile(force) {
         return new Promise((resolve) => {
-            if (this.cachedBeatmap && !forceDownload) {
-                return resolve(this);
+            if (this.hasDownloadedBeatmap() && !force) {
+                return resolve();
             }
             const url = `https://osu.ppy.sh/osu/${this.beatmapID}`;
             const dataArray = [];
@@ -6244,10 +6355,10 @@ class MapInfo {
             })
                 .on("complete", (response) => {
                 if (response.statusCode !== 200) {
-                    return resolve(this);
+                    return resolve();
                 }
                 this.cachedBeatmap = new BeatmapDecoder().decode(Buffer.concat(dataArray).toString("utf8")).result;
-                resolve(this);
+                resolve();
             });
         });
     }
@@ -6307,10 +6418,12 @@ class MapInfo {
      *
      * - Option `0`: return map title and mods used if defined
      * - Option `1`: return song source and map download link to beatmap mirrors
-     * - Option `2`: return CS, AR, OD, HP
-     * - Option `3`: return BPM, map length, max combo
-     * - Option `4`: return last update date and map status
-     * - Option `5`: return favorite count and play count
+     * - Option `2`: return circle, slider, and spinner count
+     * - Option `3`: return CS, AR, OD, HP, and max score statistics for droid
+     * - Option `4`: return CS, AR, OD, HP, and max score statistics for PC
+     * - Option `5`: return BPM, map length, and max combo
+     * - Option `6`: return last update date and map status
+     * - Option `7`: return favorite count and play count
      *
      * @param option The option to pick.
      * @param stats The custom statistics to apply. This will only be used to apply mods, custom speed multiplier, and force AR.
@@ -6333,13 +6446,9 @@ class MapInfo {
             mapParams.speedMultiplier =
                 stats.speedMultiplier ?? mapParams.speedMultiplier;
         }
-        const mapStatistics = new MapStats(mapParams).calculate();
-        mapStatistics.cs = parseFloat(mapStatistics.cs.toFixed(2));
-        mapStatistics.ar = parseFloat(mapStatistics.ar.toFixed(2));
-        mapStatistics.od = parseFloat(mapStatistics.od.toFixed(2));
-        mapStatistics.hp = parseFloat(mapStatistics.hp.toFixed(2));
         switch (option) {
             case 0: {
+                const mapStatistics = new MapStats(mapParams).calculate();
                 let string = `${this.fullTitle}${(mapStatistics.mods.length ?? 0) > 0
                     ? ` +${mapStatistics.mods
                         .map((m) => m.acronym)
@@ -6383,19 +6492,65 @@ class MapInfo {
                 return string;
             }
             case 2:
-                return `**Circles**: ${this.circles} - **Sliders**: ${this.sliders} - **Spinners**: ${this.spinners}\n**CS**: ${this.cs}${this.cs === mapStatistics.cs ? "" : ` (${mapStatistics.cs})`} - **AR**: ${this.ar}${this.ar === mapStatistics.ar ? "" : ` (${mapStatistics.ar})`} - **OD**: ${this.od}${this.od === mapStatistics.od ? "" : ` (${mapStatistics.od})`} - **HP**: ${this.hp}${this.hp === mapStatistics.hp ? "" : ` (${mapStatistics.hp})`}`;
+                return `**Circles**: ${this.circles} - **Sliders**: ${this.sliders} - **Spinners**: ${this.spinners}`;
             case 3: {
-                const maxScore = this.map?.maxDroidScore(mapStatistics) ?? 0;
+                const droidOriginalStats = new MapStats({
+                    cs: this.cs,
+                    ar: this.ar,
+                    od: this.od,
+                    hp: this.hp,
+                }).calculate({ mode: exports.modes.droid });
+                const droidModifiedStats = new MapStats(mapParams).calculate({ mode: exports.modes.droid });
+                droidOriginalStats.cs = MathUtils.round(droidOriginalStats.cs, 2);
+                droidOriginalStats.ar = MathUtils.round(droidOriginalStats.ar, 2);
+                droidOriginalStats.od = MathUtils.round(droidOriginalStats.od, 2);
+                droidOriginalStats.hp = MathUtils.round(droidOriginalStats.hp, 2);
+                droidModifiedStats.cs = MathUtils.round(droidModifiedStats.cs, 2);
+                droidModifiedStats.ar = MathUtils.round(droidModifiedStats.ar, 2);
+                droidModifiedStats.od = MathUtils.round(droidModifiedStats.od, 2);
+                droidModifiedStats.hp = MathUtils.round(droidModifiedStats.hp, 2);
+                const maxScore = this.beatmap?.maxDroidScore(new MapStats(mapParams)) ?? 0;
+                return `**CS**: ${droidOriginalStats.cs}${Precision.almostEqualsNumber(droidOriginalStats.cs, droidModifiedStats.cs)
+                    ? ""
+                    : ` (${droidModifiedStats.cs})`} - **AR**: ${droidOriginalStats.ar}${Precision.almostEqualsNumber(droidOriginalStats.ar, droidModifiedStats.ar)
+                    ? ""
+                    : ` (${droidModifiedStats.ar})`} - **OD**: ${droidOriginalStats.od}${Precision.almostEqualsNumber(droidOriginalStats.od, droidModifiedStats.od)
+                    ? ""
+                    : ` (${droidModifiedStats.od})`} - **HP**: ${droidOriginalStats.hp}${Precision.almostEqualsNumber(droidOriginalStats.hp, droidModifiedStats.hp)
+                    ? ""
+                    : ` (${droidModifiedStats.hp})`}${maxScore > 0
+                    ? `\n**Max Score**: ${maxScore.toLocaleString()}`
+                    : ""}`;
+            }
+            case 4: {
+                const mapStatistics = new MapStats(mapParams).calculate();
+                mapStatistics.cs = MathUtils.round(mapStatistics.cs, 2);
+                mapStatistics.ar = MathUtils.round(mapStatistics.ar, 2);
+                mapStatistics.od = MathUtils.round(mapStatistics.od, 2);
+                mapStatistics.hp = MathUtils.round(mapStatistics.hp, 2);
+                const maxScore = this.beatmap?.maxOsuScore(mapStatistics.mods) ?? 0;
+                return `**CS**: ${this.cs}${Precision.almostEqualsNumber(this.cs, mapStatistics.cs)
+                    ? ""
+                    : ` (${mapStatistics.cs})`} - **AR**: ${this.ar}${Precision.almostEqualsNumber(this.ar, mapStatistics.ar)
+                    ? ""
+                    : ` (${mapStatistics.ar})`} - **OD**: ${this.od}${Precision.almostEqualsNumber(this.od, mapStatistics.od)
+                    ? ""
+                    : ` (${mapStatistics.od})`} - **HP**: ${this.hp}${Precision.almostEqualsNumber(this.hp, mapStatistics.hp)
+                    ? ""
+                    : ` (${mapStatistics.hp})`}${maxScore > 0
+                    ? `\n**Max Score**: ${maxScore.toLocaleString()}`
+                    : ""}`;
+            }
+            case 5: {
+                const mapStatistics = new MapStats(mapParams).calculate();
                 const convertedBPM = this.convertBPM(mapStatistics);
                 let string = "**BPM**: ";
-                if (this.map) {
-                    const uninheritedTimingPoints = this.map.controlPoints.timing.points;
+                if (this.beatmap) {
+                    const uninheritedTimingPoints = this.beatmap.controlPoints.timing.points;
                     if (uninheritedTimingPoints.length === 1) {
                         string += `${this.bpm}${!Precision.almostEqualsNumber(this.bpm, convertedBPM)
                             ? ` (${convertedBPM})`
-                            : ""} - **Length**: ${this.convertTime(mapStatistics)} - **Max Combo**: ${this.maxCombo}x${maxScore > 0
-                            ? `\n**Max Score**: ${maxScore.toLocaleString()}`
-                            : ""}`;
+                            : ""} - **Length**: ${this.convertTime(mapStatistics)} - **Max Combo**: ${this.maxCombo}x`;
                     }
                     else {
                         let maxBPM = this.bpm;
@@ -6422,23 +6577,19 @@ class MapInfo {
                                 string += `(${convertedBPM}) `;
                             }
                         }
-                        string += `- **Length**: ${this.convertTime(mapStatistics)} - **Max Combo**: ${this.maxCombo}x${maxScore > 0
-                            ? `\n**Max score**: ${maxScore.toLocaleString()}`
-                            : ""}`;
+                        string += `- **Length**: ${this.convertTime(mapStatistics)} - **Max Combo**: ${this.maxCombo}x`;
                     }
                 }
                 else {
                     string += `${this.bpm}${!Precision.almostEqualsNumber(this.bpm, convertedBPM)
                         ? ` (${convertedBPM})`
-                        : ""} - **Length**: ${this.convertTime(mapStatistics)} - **Max Combo**: ${this.maxCombo}x${maxScore > 0
-                        ? `\n**Max score**: ${maxScore.toLocaleString()}`
-                        : ""}`;
+                        : ""} - **Length**: ${this.convertTime(mapStatistics)} - **Max Combo**: ${this.maxCombo}x`;
                 }
                 return string;
             }
-            case 4:
+            case 6:
                 return `**Last Update**: ${this.lastUpdate.toUTCString()} | **${this.convertStatus()}**`;
-            case 5:
+            case 7:
                 return `❤️ **${this.favorites.toLocaleString()}** - ▶️ **${this.plays.toLocaleString()}**`;
             default:
                 throw {