@rian8337/osu-base 2.1.1 → 3.0.0-beta.1

package/dist/index.js

@@ -311,7 +311,9 @@ class APIRequestBuilder {
             })
                 .on("complete", async (response) => {
                 ++this.fetchAttempts;
-                if (response.statusCode !== 200 && this.fetchAttempts < 5) {
+                const { statusCode } = response;
+                if ((statusCode === 500 || statusCode === 503) &&
+                    this.fetchAttempts < 5) {
                     console.error(`Request to ${url} failed; ${this.fetchAttempts} attempts so far; retrying`);
                     await Utils.sleep(0.2);
                     return resolve(this.sendRequest());
@@ -390,7 +392,7 @@ exports.objectTypes = void 0;
 })(exports.objectTypes || (exports.objectTypes = {}));
 
 /**
- * Based on `Vector2` class in C#.
+ * Represents a two-dimensional vector.
  */
 class Vector2 {
     /**
@@ -1299,12 +1301,20 @@ class DifficultyControlPoint extends ControlPoint {
      * The slider speed multiplier of the control point.
      */
     speedMultiplier;
+    /**
+     * Whether or not slider ticks should be generated at this control point.
+     *
+     * This exists for backwards compatibility with maps that abuse NaN slider velocity behavior on osu!stable (e.g. /b/2628991).
+     */
+    generateTicks;
     constructor(values) {
         super(values);
         this.speedMultiplier = values.speedMultiplier;
+        this.generateTicks = values.generateTicks;
     }
     isRedundant(existing) {
-        return this.speedMultiplier === existing.speedMultiplier;
+        return (this.speedMultiplier === existing.speedMultiplier &&
+            this.generateTicks === existing.generateTicks);
     }
     toString() {
         return ("{ time: " +
@@ -1323,6 +1333,7 @@ class DifficultyControlPointManager extends ControlPointManager {
     defaultControlPoint = new DifficultyControlPoint({
         time: 0,
         speedMultiplier: 1,
+        generateTicks: true,
     });
     controlPointAt(time) {
         return this.binarySearchWithFallback(time);
@@ -1717,26 +1728,46 @@ class Beatmap {
      */
     maxDroidScore(stats) {
         let scoreMultiplier = 1;
-        if (stats.mods.every((m) => m.droidRanked)) {
-            let scoreSpeedMultiplier = 1;
-            const speedMultiplier = stats.speedMultiplier;
-            if (speedMultiplier > 1) {
-                scoreSpeedMultiplier += (speedMultiplier - 1) * 0.24;
-            }
-            else if (speedMultiplier < 1) {
-                scoreSpeedMultiplier = Math.pow(0.3, (1 - speedMultiplier) * 4);
+        for (const mod of stats.mods) {
+            if (mod.isApplicableToDroid()) {
+                scoreMultiplier *= mod.droidScoreMultiplier;
             }
-            scoreMultiplier =
-                stats.mods.reduce((a, v) => a * v.scoreMultiplier, 1) *
-                    scoreSpeedMultiplier;
+        }
+        const { speedMultiplier } = stats;
+        if (speedMultiplier >= 1) {
+            scoreMultiplier *= 1 + (speedMultiplier - 1) * 0.24;
         }
         else {
-            scoreMultiplier = 0;
+            scoreMultiplier *= Math.pow(0.3, (1 - speedMultiplier) * 4);
         }
-        return this.maxScore(1 +
+        const difficultyMultiplier = 1 +
             this.difficulty.od / 10 +
             this.difficulty.hp / 10 +
-            (this.difficulty.cs - 3) / 4, scoreMultiplier);
+            (this.difficulty.cs - 3) / 4;
+        let combo = 0;
+        let score = 0;
+        for (const object of this.hitObjects.objects) {
+            if (!(object instanceof Slider)) {
+                score += Math.floor(300 + (300 * combo * difficultyMultiplier) / 25);
+                ++combo;
+                continue;
+            }
+            const ticksPerSpan = object.ticks;
+            const totalTicks = ticksPerSpan * (object.repeats + 1);
+            // Apply slider head.
+            score += 30;
+            ++combo;
+            // Apply slider repeats.
+            score += 30 * object.repeats;
+            combo += object.repeats;
+            // Apply slider ticks.
+            score += 10 * totalTicks;
+            combo += totalTicks;
+            // Apply slider end.
+            score += Math.floor(300 + (300 * combo * difficultyMultiplier) / 25);
+            ++combo;
+        }
+        return Math.floor(score * scoreMultiplier);
     }
     /**
      * Calculates the osu!standard maximum score of the beatmap without taking spinner bonus into account.
@@ -1746,6 +1777,12 @@ class Beatmap {
     maxOsuScore(mods = []) {
         const accumulatedDiffPoints = this.difficulty.cs + this.difficulty.hp + this.difficulty.od;
         let difficultyMultiplier = 2;
+        let scoreMultiplier = 1;
+        for (const mod of mods) {
+            if (mod.isApplicableToOsu()) {
+                scoreMultiplier *= mod.pcScoreMultiplier;
+            }
+        }
         switch (true) {
             case accumulatedDiffPoints <= 5:
                 difficultyMultiplier = 2;
@@ -1763,15 +1800,6 @@ class Beatmap {
                 difficultyMultiplier = 6;
                 break;
         }
-        return this.maxScore(difficultyMultiplier, mods.reduce((a, v) => a * v.scoreMultiplier, 1));
-    }
-    /**
-     * Calculates the maximum score with a given difficulty and score multiplier.
-     *
-     * @param difficultyMultiplier The difficulty multiplier.
-     * @param scoreMultiplier The score multiplier.
-     */
-    maxScore(difficultyMultiplier, scoreMultiplier) {
         let combo = 0;
         let score = 0;
         for (const object of this.hitObjects.objects) {
@@ -1782,11 +1810,18 @@ class Beatmap {
                 ++combo;
                 continue;
             }
-            const tickCount = object.nestedHitObjects.filter((v) => v instanceof SliderTick).length;
-            // Apply sliderhead, slider repeats, and slider ticks
-            score += 30 * (object.repeats + 1) + 10 * tickCount;
-            combo += tickCount + (object.repeats + 1);
-            // Apply sliderend
+            const ticksPerSpan = object.ticks;
+            const totalTicks = ticksPerSpan * (object.repeats + 1);
+            // Apply slider head.
+            score += 30;
+            ++combo;
+            // Apply slider repeats.
+            score += 30 * object.repeats;
+            combo += object.repeats;
+            // Apply slider ticks.
+            score += 10 * totalTicks;
+            combo += totalTicks;
+            // Apply slider end.
             score += Math.floor(300 +
                 (300 * combo * difficultyMultiplier * scoreMultiplier) / 25);
             ++combo;
@@ -1999,160 +2034,163 @@ class OsuHitWindow extends HitWindow {
  * Represents a mod.
  */
 class Mod {
+    /**
+     * Whether this mod can be applied to osu!droid.
+     */
+    isApplicableToDroid() {
+        return "droidRanked" in this;
+    }
+    /**
+     * Whether this mod can be applied to osu!standard.
+     */
+    isApplicableToOsu() {
+        return "pcRanked" in this;
+    }
 }
 
 /**
  * Represents the DoubleTime mod.
  */
 class ModDoubleTime extends Mod {
-    scoreMultiplier = 1.12;
     acronym = "DT";
     name = "DoubleTime";
     droidRanked = true;
     pcRanked = true;
+    droidScoreMultiplier = 1.12;
+    pcScoreMultiplier = 1.12;
     bitwise = 1 << 6;
     droidString = "d";
-    droidOnly = false;
 }
 
 /**
  * Represents the HalfTime mod.
  */
 class ModHalfTime extends Mod {
-    scoreMultiplier = 0.3;
     acronym = "HT";
     name = "HalfTime";
     droidRanked = true;
     pcRanked = true;
+    droidScoreMultiplier = 0.3;
+    pcScoreMultiplier = 0.3;
     bitwise = 1 << 8;
     droidString = "t";
-    droidOnly = false;
 }
 
 /**
  * Represents the NightCore mod.
  */
 class ModNightCore extends Mod {
-    scoreMultiplier = 1.12;
     acronym = "NC";
     name = "NightCore";
     droidRanked = true;
     pcRanked = true;
+    droidScoreMultiplier = 1.12;
+    pcScoreMultiplier = 1.12;
     bitwise = 1 << 9;
     droidString = "c";
-    droidOnly = false;
 }
 
 /**
  * Represents the HardRock mod.
  */
 class ModHardRock extends Mod {
-    scoreMultiplier = 1.06;
     acronym = "HR";
     name = "HardRock";
     bitwise = 1 << 4;
     droidRanked = true;
     pcRanked = true;
+    droidScoreMultiplier = 1.06;
+    pcScoreMultiplier = 1.06;
     droidString = "r";
-    droidOnly = false;
 }
 
 /**
  * Represents the Easy mod.
  */
 class ModEasy extends Mod {
-    scoreMultiplier = 0.5;
     acronym = "EZ";
     name = "Easy";
     droidRanked = true;
     pcRanked = true;
+    droidScoreMultiplier = 0.5;
+    pcScoreMultiplier = 0.5;
     bitwise = 1 << 1;
     droidString = "e";
-    droidOnly = false;
 }
 
 /**
  * Represents the Precise mod.
  */
 class ModPrecise extends Mod {
-    scoreMultiplier = 1.06;
     acronym = "PR";
     name = "Precise";
     droidRanked = true;
-    pcRanked = false;
-    bitwise = Number.NaN;
+    droidScoreMultiplier = 1.06;
     droidString = "s";
-    droidOnly = true;
 }
 
 /**
  * Represents the SmallCircle mod.
  */
 class ModSmallCircle extends Mod {
-    scoreMultiplier = 1.06;
     acronym = "SC";
     name = "SmallCircle";
     droidRanked = false;
-    pcRanked = false;
-    bitwise = Number.NaN;
+    droidScoreMultiplier = 1.06;
     droidString = "m";
-    droidOnly = true;
 }
 
 /**
  * Represents the ReallyEasy mod.
  */
 class ModReallyEasy extends Mod {
-    scoreMultiplier = 0.4;
     acronym = "RE";
     name = "ReallyEasy";
     droidRanked = false;
-    pcRanked = false;
-    bitwise = Number.NaN;
+    droidScoreMultiplier = 0.4;
     droidString = "l";
-    droidOnly = true;
 }
 
 /**
  * Represents the Auto mod.
  */
 class ModAuto extends Mod {
-    scoreMultiplier = 0;
     acronym = "AT";
     name = "Autoplay";
     droidRanked = false;
     pcRanked = false;
+    droidScoreMultiplier = 1;
+    pcScoreMultiplier = 1;
     bitwise = 1 << 11;
     droidString = "a";
-    droidOnly = false;
 }
 
 /**
  * Represents the Autopilot mod.
  */
 class ModAutopilot extends Mod {
-    scoreMultiplier = 0;
     acronym = "AP";
     name = "Autopilot";
     droidRanked = false;
     pcRanked = false;
+    droidScoreMultiplier = 0.001;
+    pcScoreMultiplier = 0;
     bitwise = 1 << 13;
     droidString = "p";
-    droidOnly = false;
 }
 
 /**
  * Represents the Flashlight mod.
  */
 class ModFlashlight extends Mod {
-    scoreMultiplier = 1.12;
     acronym = "FL";
     name = "Flashlight";
     droidRanked = false;
     pcRanked = true;
+    droidScoreMultiplier = 1.12;
+    pcScoreMultiplier = 1.12;
     bitwise = 1 << 10;
     droidString = "i";
-    droidOnly = false;
 }
 
 /**
@@ -2161,112 +2199,106 @@ class ModFlashlight extends Mod {
 class ModHidden extends Mod {
     static fadeInDurationMultiplier = 0.4;
     static fadeOutDurationMultiplier = 0.3;
-    scoreMultiplier = 1.06;
     acronym = "HD";
     name = "Hidden";
     bitwise = 1 << 3;
     droidRanked = true;
     pcRanked = true;
+    droidScoreMultiplier = 1.06;
+    pcScoreMultiplier = 1.06;
     droidString = "h";
-    droidOnly = false;
 }
 
 /**
  * Represents the NoFail mod.
  */
 class ModNoFail extends Mod {
-    scoreMultiplier = 0.5;
     acronym = "NF";
     name = "NoFail";
     droidRanked = true;
     pcRanked = true;
+    droidScoreMultiplier = 0.5;
+    pcScoreMultiplier = 0.5;
     bitwise = 1 << 0;
     droidString = "n";
-    droidOnly = false;
 }
 
 /**
  * Represents the Perfect mod.
  */
 class ModPerfect extends Mod {
-    scoreMultiplier = 1;
     acronym = "PF";
     name = "Perfect";
     droidRanked = false;
     pcRanked = true;
+    droidScoreMultiplier = 1;
+    pcScoreMultiplier = 1;
     bitwise = 1 << 14;
     droidString = "f";
-    droidOnly = false;
 }
 
 /**
  * Represents the Relax mod.
  */
 class ModRelax extends Mod {
-    scoreMultiplier = 0;
     acronym = "RX";
     name = "Relax";
     droidRanked = false;
     pcRanked = false;
+    droidScoreMultiplier = 0.001;
+    pcScoreMultiplier = 0;
     bitwise = 1 << 7;
     droidString = "x";
-    droidOnly = false;
 }
 
 /**
  * Represents the ScoreV2 mod.
  */
 class ModScoreV2 extends Mod {
-    scoreMultiplier = 1;
     acronym = "V2";
     name = "ScoreV2";
     droidRanked = false;
     pcRanked = false;
+    droidScoreMultiplier = 1;
+    pcScoreMultiplier = 1;
     bitwise = 1 << 29;
     droidString = "v";
-    droidOnly = false;
 }
 
 /**
  * Represents the SpunOut mod.
  */
 class ModSpunOut extends Mod {
-    scoreMultiplier = 0.9;
     acronym = "SO";
     name = "SpunOut";
-    droidRanked = false;
     pcRanked = true;
+    pcScoreMultiplier = 0.9;
     bitwise = 1 << 12;
-    droidString = "";
-    droidOnly = false;
 }
 
 /**
  * Represents the SuddenDeath mod.
  */
 class ModSuddenDeath extends Mod {
-    scoreMultiplier = 1;
     acronym = "SD";
     name = "Sudden Death";
     droidRanked = false;
     pcRanked = true;
+    droidScoreMultiplier = 1;
+    pcScoreMultiplier = 1;
     bitwise = 1 << 5;
     droidString = "u";
-    droidOnly = false;
 }
 
 /**
  * Represents the TouchDevice mod.
  */
 class ModTouchDevice extends Mod {
-    scoreMultiplier = 1;
     acronym = "TD";
     name = "TouchDevice";
-    droidRanked = true;
     pcRanked = true;
+    pcScoreMultiplier = 1;
     bitwise = 1 << 2;
-    droidString = "";
-    droidOnly = false;
 }
 
 /**
@@ -2331,7 +2363,8 @@ class ModUtil {
      * @param options Options for parsing behavior.
      */
     static droidStringToMods(str, options) {
-        return this.processParsingOptions(this.allMods.filter((m) => m.droidString && str.toLowerCase().includes(m.droidString)), options);
+        return this.processParsingOptions(this.allMods.filter((m) => m.isApplicableToDroid() &&
+            str.toLowerCase().includes(m.droidString)), options);
     }
     /**
      * Gets a list of mods from a PC modbits.
@@ -2340,7 +2373,7 @@ class ModUtil {
      * @param options Options for parsing behavior.
      */
     static pcModbitsToMods(modbits, options) {
-        return this.processParsingOptions(this.allMods.filter((m) => m.bitwise & modbits), options);
+        return this.processParsingOptions(this.allMods.filter((m) => m.isApplicableToOsu() && (m.bitwise & modbits)), options);
     }
     /**
      * Gets a list of mods from a PC mod string, such as "HDHR".
@@ -2381,11 +2414,10 @@ class ModUtil {
      */
     static checkIncompatibleMods(mods) {
         for (const incompatibleMod of this.incompatibleMods) {
-            const fulfilledMods = mods.filter((m) => incompatibleMod.map((v) => v.acronym).includes(m.acronym));
+            const fulfilledMods = mods.filter((m) => incompatibleMod.some((v) => m.acronym === v.acronym));
             if (fulfilledMods.length > 1) {
-                mods = mods.filter((m) => !incompatibleMod
-                    .map((v) => v.acronym)
-                    .includes(m.acronym));
+                mods = mods.filter((m) => incompatibleMod
+                    .every((v) => m.acronym !== v.acronym));
                 // Keep the first selected mod
                 mods.push(fulfilledMods[0]);
             }
@@ -3304,6 +3336,9 @@ class Decoder {
         for (let line of str.split("\n")) {
             this.currentLine = line;
             ++this.line;
+            if (this.shouldSkipLine(line)) {
+                continue;
+            }
             if (this.section !== BeatmapSection.metadata) {
                 // Comments should not be stripped from metadata lines, as the song metadata may contain "//" as valid data.
                 const index = line.indexOf("//");
@@ -3341,6 +3376,15 @@ class Decoder {
         }
         return this;
     }
+    /**
+     * Determines whether a line should be skipped.
+     *
+     * @param line The line to determine.
+     * @returns Whether the line should be skipped.
+     */
+    shouldSkipLine(line) {
+        return !line || line.trimStart().startsWith("//");
+    }
     /**
      * Internal decoder function for decoding a line.
      *
@@ -3420,29 +3464,43 @@ class SectionDecoder {
      * @param str The string to parse.
      * @param min The minimum threshold. Defaults to `-ParserConstants.MAX_PARSE_VALUE`.
      * @param max The maximum threshold. Defaults to `ParserConstants.MAX_PARSE_VALUE`.
+     * @param allowNaN Whether to allow NaN.
      * @returns The parsed integer.
      */
-    tryParseInt(str, min = -ParserConstants.MAX_PARSE_VALUE, max = ParserConstants.MAX_PARSE_VALUE) {
+    tryParseInt(str, min = -ParserConstants.MAX_PARSE_VALUE, max = ParserConstants.MAX_PARSE_VALUE, allowNaN = false) {
         const num = parseInt(str);
-        if (!this.isNumberValid(num, min, max)) {
-            throw new RangeError(`Couldn't parse ${str} into an int: value is either invalid, too low, or too high`);
+        if (num < min) {
+            throw new RangeError("Value is too low");
+        }
+        if (num > max) {
+            throw new RangeError("Value is too high");
+        }
+        if (!allowNaN && Number.isNaN(num)) {
+            throw new RangeError("Not a number");
         }
         return num;
     }
     /**
      * Attempts to parse a string into a float.
      *
-     * Throws an exception when the resulting value is invalid (such as NaN), too low, or too high.
+     * Throws an exception when the resulting value is too low or too high.
      *
      * @param str The string to parse.
      * @param min The minimum threshold. Defaults to `-ParserConstants.MAX_PARSE_VALUE`.
      * @param max The maximum threshold. Defaults to `ParserConstants.MAX_PARSE_VALUE`.
+     * @param allowNaN Whether to allow NaN.
      * @returns The parsed float.
      */
-    tryParseFloat(str, min = -ParserConstants.MAX_PARSE_VALUE, max = ParserConstants.MAX_PARSE_VALUE) {
+    tryParseFloat(str, min = -ParserConstants.MAX_PARSE_VALUE, max = ParserConstants.MAX_PARSE_VALUE, allowNaN = false) {
         const num = parseFloat(str);
-        if (!this.isNumberValid(num, min, max)) {
-            throw new RangeError(`Couldn't parse ${str} into a float: value is either invalid, too low, or too high`);
+        if (num < min) {
+            throw new RangeError("Value is too low");
+        }
+        if (num > max) {
+            throw new RangeError("Value is too high");
+        }
+        if (!allowNaN && Number.isNaN(num)) {
+            throw new RangeError("Not a number");
         }
         return num;
     }
@@ -3502,8 +3560,8 @@ class BeatmapHitObjectsDecoder extends SectionDecoder {
             }
             const repetitions = Math.max(0, this.tryParseInt(this.setPosition(s[6]), -ParserConstants.MAX_PARSE_VALUE, ParserConstants.MAX_REPETITIONS_VALUE));
             const distance = Math.max(0, this.tryParseFloat(this.setPosition(s[7])));
-            const speedMultiplierTimingPoint = this.target.controlPoints.difficulty.controlPointAt(time);
-            const msPerBeatTimingPoint = this.target.controlPoints.timing.controlPointAt(time);
+            const difficultyControlPoint = this.target.controlPoints.difficulty.controlPointAt(time);
+            const timingControlPoint = this.target.controlPoints.timing.controlPointAt(time);
             const points = [new Vector2(0, 0)];
             const pointSplit = this.setPosition(s[5]).split("|");
             let pathType = pointSplit.shift();
@@ -3573,6 +3631,23 @@ class BeatmapHitObjectsDecoder extends SectionDecoder {
             comboOffset += this.extraComboOffset;
             this.forceNewCombo = false;
             this.extraComboOffset = 0;
+            let tickDistanceMultiplier = Number.POSITIVE_INFINITY;
+            if (difficultyControlPoint.generateTicks) {
+                if (this.isNumberValid(timingControlPoint.msPerBeat, ParserConstants.MIN_MSPERBEAT_VALUE, ParserConstants.MAX_MSPERBEAT_VALUE)) {
+                    // Prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
+                    // This results in more (or less) ticks being generated in <v8 maps for the same time duration.
+                    //
+                    // This additional check is used in case BPM goes very low or very high.
+                    // When lazer is final, this should be revisited.
+                    tickDistanceMultiplier =
+                        this.target.formatVersion < 8
+                            ? 1 / difficultyControlPoint.speedMultiplier
+                            : 1;
+                }
+                else {
+                    tickDistanceMultiplier = 0;
+                }
+            }
             object = new Slider({
                 position: position,
                 startTime: time,
@@ -3582,20 +3657,11 @@ class BeatmapHitObjectsDecoder extends SectionDecoder {
                 nodeSamples: nodeSamples,
                 repetitions: repetitions,
                 path: path,
-                speedMultiplier: MathUtils.clamp(speedMultiplierTimingPoint.speedMultiplier, ParserConstants.MIN_SPEEDMULTIPLIER_VALUE, ParserConstants.MAX_SPEEDMULTIPLIER_VALUE),
-                msPerBeat: msPerBeatTimingPoint.msPerBeat,
+                speedMultiplier: MathUtils.clamp(difficultyControlPoint.speedMultiplier, ParserConstants.MIN_SPEEDMULTIPLIER_VALUE, ParserConstants.MAX_SPEEDMULTIPLIER_VALUE),
+                msPerBeat: timingControlPoint.msPerBeat,
                 mapSliderVelocity: this.target.difficulty.sliderMultiplier,
                 mapTickRate: this.target.difficulty.sliderTickRate,
-                // Prior to v8, speed multipliers don't adjust for how many ticks are generated over the same distance.
-                // This results in more (or less) ticks being generated in <v8 maps for the same time duration.
-                //
-                // This additional check is used in case BPM goes very low or very high.
-                // When lazer is final, this should be revisited.
-                tickDistanceMultiplier: this.isNumberValid(msPerBeatTimingPoint.msPerBeat, ParserConstants.MIN_MSPERBEAT_VALUE, ParserConstants.MAX_MSPERBEAT_VALUE)
-                    ? this.target.formatVersion < 8
-                        ? 1 / speedMultiplierTimingPoint.speedMultiplier
-                        : 1
-                    : 0,
+                tickDistanceMultiplier: tickDistanceMultiplier,
             });
         }
         else if (type & exports.objectTypes.spinner) {
@@ -4143,7 +4209,9 @@ class BeatmapControlPointsDecoder extends SectionDecoder {
             throw new Error("Ignoring malformed timing point");
         }
         const time = this.target.getOffsetTime(this.tryParseFloat(this.setPosition(s[0])));
-        const msPerBeat = this.tryParseFloat(this.setPosition(s[1]));
+        // msPerBeat is allowed to be NaN to handle an edge case in which some
+        // beatmaps use NaN slider velocity to disable slider tick generation.
+        const msPerBeat = this.tryParseFloat(this.setPosition(s[1]), undefined, undefined, true);
         let timeSignature = 4;
         if (s.length >= 3) {
             timeSignature = this.tryParseInt(this.setPosition(s[2]));
@@ -4170,7 +4238,14 @@ class BeatmapControlPointsDecoder extends SectionDecoder {
             kiaiMode = !!(effectBitFlags & EffectFlags.kiai);
             omitFirstBarSignature = !!(effectBitFlags & EffectFlags.omitFirstBarLine);
         }
-        if (msPerBeat >= 0) {
+        let timingChange = true;
+        if (s.length >= 7) {
+            timingChange = s[6] === "1";
+        }
+        if (timingChange) {
+            if (Number.isNaN(msPerBeat)) {
+                throw new Error("Beat length cannot be NaN in a timing control point");
+            }
             this.target.controlPoints.timing.add(new TimingControlPoint({
                 time: time,
                 msPerBeat: msPerBeat,
@@ -4179,7 +4254,9 @@ class BeatmapControlPointsDecoder extends SectionDecoder {
         }
         this.target.controlPoints.difficulty.add(new DifficultyControlPoint({
             time: time,
+            // If msPerBeat is NaN, speedMultiplier should still be 1 because all comparisons against NaN are false.
             speedMultiplier: msPerBeat < 0 ? 100 / -msPerBeat : 1,
+            generateTicks: !Number.isNaN(msPerBeat),
         }));
         this.target.controlPoints.effect.add(new EffectControlPoint({
             time: time,