@rian8337/osu-base 4.0.0-beta.23 → 4.0.0-beta.25

package/dist/index.js

@@ -1043,6 +1043,30 @@ function convertApproachRateMilliseconds(ms) {
  * Represents a hitobject in a beatmap.
  */
 class HitObject {
+    /**
+     * The position of the hitobject in osu!pixels.
+     */
+    get position() {
+        return this._position;
+    }
+    /**
+     * The position of the hitobject in osu!pixels.
+     */
+    set position(value) {
+        this._position = value;
+    }
+    /**
+     * The end position of the hitobject in osu!pixels.
+     */
+    get endPosition() {
+        return this.position;
+    }
+    /**
+     * The end time of the hitobject.
+     */
+    get endTime() {
+        return this.startTime;
+    }
     /**
      * The duration of the hitobject.
      */
@@ -1090,13 +1114,13 @@ class HitObject {
         return res.substring(0, Math.max(0, res.length - 3));
     }
     /**
-     * The radius of this hitobject,
+     * The radius of this hitobject in osu!pixels.
      */
     get radius() {
-        return HitObject.baseRadius * this._scale;
+        return HitObject.baseRadius * this.scale;
     }
     constructor(values) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c;
         /**
          * The samples to be played when this hitobject is hit.
          *
@@ -1125,12 +1149,10 @@ class HitObject {
          */
         this.timeFadeIn = 400;
         this.startTime = values.startTime;
-        this.endTime = (_a = values.endTime) !== null && _a !== void 0 ? _a : values.startTime;
-        this.type = (_b = values.type) !== null && _b !== void 0 ? _b : exports.ObjectTypes.circle;
-        this.position = values.position;
-        this.endPosition = (_c = values.endPosition) !== null && _c !== void 0 ? _c : this.position;
-        this.isNewCombo = (_d = values.newCombo) !== null && _d !== void 0 ? _d : false;
-        this.comboOffset = (_e = values.comboOffset) !== null && _e !== void 0 ? _e : 0;
+        this.type = (_a = values.type) !== null && _a !== void 0 ? _a : exports.ObjectTypes.circle;
+        this._position = values.position;
+        this.isNewCombo = (_b = values.newCombo) !== null && _b !== void 0 ? _b : false;
+        this.comboOffset = (_c = values.comboOffset) !== null && _c !== void 0 ? _c : 0;
     }
     /**
      * Applies default values to this hitobject.
@@ -1151,11 +1173,11 @@ class HitObject {
                 const cs = calculateDroidDifficultyStatistics({
                     circleSize: difficulty.cs,
                 }).circleSize;
-                this._scale = CircleSizeCalculator.standardCSToStandardScale(cs, true);
+                this.scale = CircleSizeCalculator.standardCSToStandardScale(cs, true);
                 break;
             }
             case exports.Modes.osu:
-                this._scale = CircleSizeCalculator.standardCSToStandardScale(difficulty.cs, true);
+                this.scale = CircleSizeCalculator.standardCSToStandardScale(difficulty.cs, true);
                 break;
         }
     }
@@ -1179,9 +1201,11 @@ class HitObject {
     getStackOffset(mode) {
         switch (mode) {
             case exports.Modes.droid:
-                return new Vector2(this._stackHeight * this._scale * 4);
+                return new Vector2(this.stackHeight *
+                    CircleSizeCalculator.standardScaleToDroidScale(this.scale, true) *
+                    4);
             case exports.Modes.osu:
-                return new Vector2(this._stackHeight * this._scale * -6.4);
+                return new Vector2(this.stackHeight * this.scale * -6.4);
         }
     }
     /**
@@ -1252,7 +1276,7 @@ class SliderNestedHitObject extends HitObject {
         this.spanStartTime = values.spanStartTime;
     }
     toString() {
-        return `Position: [${this.position.x}, ${this.position.y}], span index: ${this.spanIndex}, span start time: ${this.spanStartTime}`;
+        return `Position: [${this._position.x}, ${this._position.y}], span index: ${this.spanIndex}, span start time: ${this.spanStartTime}`;
     }
 }
 
@@ -1283,10 +1307,83 @@ class SliderTick extends SliderNestedHitObject {
 class SliderTail extends SliderNestedHitObject {
 }
 
+/**
+ * Describes a value that can be cached.
+ */
+class Cached {
+    /**
+     * The cached value.
+     */
+    get value() {
+        if (!this._isValid) {
+            throw new Error("May not query value of an invalid cache.");
+        }
+        return this._value;
+    }
+    /**
+     * The cached value.
+     */
+    set value(value) {
+        this._value = value;
+        this._isValid = true;
+    }
+    /**
+     * Whether the cache is valid.
+     */
+    get isValid() {
+        return this._isValid;
+    }
+    constructor(value) {
+        this._isValid = true;
+        this._value = value;
+    }
+    /**
+     * Invalidates the cache of this `Cached`.
+     *
+     * @return `true` if the cache was invalidated from a valid state.
+     */
+    invalidate() {
+        if (this._isValid) {
+            this._isValid = false;
+            return true;
+        }
+        return false;
+    }
+}
+
 /**
  * Represents a slider in a beatmap.
  */
 class Slider extends HitObject {
+    get position() {
+        return super.position;
+    }
+    set position(value) {
+        super.position = value;
+        this.updateNestedPositions();
+    }
+    get endTime() {
+        return (this.startTime + (this.spanCount * this.distance) / this.velocity);
+    }
+    get endPosition() {
+        if (!this.endPositionCache.isValid) {
+            this.endPositionCache.value = this.position.add(this.curvePositionAt(1));
+        }
+        return this.endPositionCache.value;
+    }
+    /**
+     * The slider's path.
+     */
+    get path() {
+        return this._path;
+    }
+    /**
+     * The slider's path.
+     */
+    set path(value) {
+        this._path = value;
+        this.updateNestedPositions();
+    }
     /**
      * The slider's velocity.
      */
@@ -1330,6 +1427,18 @@ class Slider extends HitObject {
     get spanDuration() {
         return this.duration / this.spanCount;
     }
+    /**
+     * The slider's head.
+     */
+    get head() {
+        return this._head;
+    }
+    /**
+     * The slider's tail.
+     */
+    get tail() {
+        return this._tail;
+    }
     /**
      * The amount of slider ticks in this slider.
      *
@@ -1387,31 +1496,21 @@ class Slider extends HitObject {
          * as few movements as possible. This is set and used by difficulty calculation.
          */
         this.lazyTravelTime = 0;
-        this.path = values.path;
+        this._path = values.path;
         this.nodeSamples = values.nodeSamples;
         this._repeatCount = values.repeatCount;
-        this.endPosition = this.position.add(this.curvePositionAt(1));
+        this.endPositionCache = new Cached(this.position.add(this.curvePositionAt(1)));
         this.tickDistanceMultiplier = values.tickDistanceMultiplier;
-        this.head = new SliderHead({
-            position: this.position,
+        this._head = new SliderHead({
+            position: this._position,
             startTime: this.startTime,
         });
-        this.tail = new SliderTail({
+        this._tail = new SliderTail({
             position: this.endPosition,
             startTime: this.endTime,
             spanIndex: this.spanCount - 1,
             spanStartTime: this.startTime + this.spanDuration * this.spanCount,
         });
-        // Create sliding samples
-        const bankSamples = this.samples.filter((v) => v instanceof BankHitSampleInfo);
-        const normalSample = bankSamples.find((v) => v.name === BankHitSampleInfo.HIT_NORMAL);
-        if (normalSample) {
-            this.auxiliarySamples.push(new BankHitSampleInfo("sliderslide", normalSample.bank, normalSample.customSampleBank, normalSample.volume, normalSample.isLayered));
-        }
-        const whistleSample = bankSamples.find((v) => v.name === BankHitSampleInfo.HIT_WHISTLE);
-        if (whistleSample) {
-            this.auxiliarySamples.push(new BankHitSampleInfo("sliderwhistle", whistleSample.bank, whistleSample.customSampleBank, whistleSample.volume, whistleSample.isLayered));
-        }
     }
     applyDefaults(controlPoints, difficulty, mode) {
         super.applyDefaults(controlPoints, difficulty, mode);
@@ -1426,20 +1525,28 @@ class Slider extends HitObject {
                 (timingPoint.msPerBeat * bpmMultiplier);
         // WARNING: this is intentionally not computed as `BASE_SCORING_DISTANCE * difficulty.sliderMultiplier`
         // for backwards compatibility reasons (intentionally introducing floating point errors to match osu!stable).
-        const scoringDistance = this._velocity * timingPoint.msPerBeat;
+        const scoringDistance = this.velocity * timingPoint.msPerBeat;
         this.generateTicks = difficultyPoint.generateTicks;
         this._tickDistance = this.generateTicks
             ? (scoringDistance / difficulty.sliderTickRate) *
                 this.tickDistanceMultiplier
             : Number.POSITIVE_INFINITY;
-        this.endTime =
-            this.startTime +
-                (this.spanCount * this.path.expectedDistance) / this._velocity;
         this.createNestedHitObjects(mode);
         this.nestedHitObjects.forEach((v) => v.applyDefaults(controlPoints, difficulty, mode));
     }
     applySamples(controlPoints) {
         super.applySamples(controlPoints);
+        // Create sliding samples
+        this.auxiliarySamples.length = 0;
+        const bankSamples = this.samples.filter((v) => v instanceof BankHitSampleInfo);
+        const normalSample = bankSamples.find((v) => v.name === BankHitSampleInfo.HIT_NORMAL);
+        if (normalSample) {
+            this.auxiliarySamples.push(new BankHitSampleInfo("sliderslide", normalSample.bank, normalSample.customSampleBank, normalSample.volume, normalSample.isLayered));
+        }
+        const whistleSample = bankSamples.find((v) => v.name === BankHitSampleInfo.HIT_WHISTLE);
+        if (whistleSample) {
+            this.auxiliarySamples.push(new BankHitSampleInfo("sliderwhistle", whistleSample.bank, whistleSample.customSampleBank, whistleSample.volume, whistleSample.isLayered));
+        }
         this.nodeSamples.forEach((nodeSample, i) => {
             const time = this.startTime +
                 i * this.spanDuration +
@@ -1481,7 +1588,7 @@ class Slider extends HitObject {
     }
     createNestedHitObjects(mode) {
         this.nestedHitObjects.length = 0;
-        this.head = new SliderHead({
+        this._head = new SliderHead({
             position: this.position,
             startTime: this.startTime,
         });
@@ -1490,9 +1597,9 @@ class Slider extends HitObject {
         // This exists for edge cases such as /b/1573664 where the beatmap has been edited by the user, and should never be reached in normal usage.
         const maxLength = 100000;
         const length = Math.min(maxLength, this.path.expectedDistance);
-        const tickDistance = MathUtils.clamp(this._tickDistance, 0, length);
+        const tickDistance = MathUtils.clamp(this.tickDistance, 0, length);
         if (tickDistance !== 0 && this.generateTicks) {
-            const minDistanceFromEnd = this._velocity * 10;
+            const minDistanceFromEnd = this.velocity * 10;
             for (let span = 0; span < this.spanCount; ++span) {
                 const spanStartTime = this.startTime + span * this.spanDuration;
                 const reversed = span % 2 === 1;
@@ -1534,7 +1641,7 @@ class Slider extends HitObject {
         }
         switch (mode) {
             case exports.Modes.droid:
-                this.tail = new SliderTail({
+                this._tail = new SliderTail({
                     position: this.endPosition,
                     startTime: this.endTime,
                     spanIndex: this.spanCount - 1,
@@ -1554,7 +1661,7 @@ class Slider extends HitObject {
                 const finalSpanEndTime = Math.max(this.startTime + this.duration / 2, finalSpanStartTime +
                     this.spanDuration -
                     Slider.legacyLastTickOffset);
-                this.tail = new SliderTail({
+                this._tail = new SliderTail({
                     position: this.endPosition,
                     startTime: finalSpanEndTime,
                     spanIndex: this.spanCount - 1,
@@ -1568,6 +1675,7 @@ class Slider extends HitObject {
         this.updateNestedSamples();
     }
     updateNestedPositions() {
+        this.endPositionCache.invalidate();
         this.head.position = this.position;
         this.tail.position = this.endPosition;
     }
@@ -2253,7 +2361,7 @@ class Circle extends HitObject {
         super(values);
     }
     toString() {
-        return `Position: [${this.position.x}, ${this.position.y}]`;
+        return `Position: [${this._position.x}, ${this._position.y}]`;
     }
 }
 
@@ -2264,8 +2372,16 @@ class Circle extends HitObject {
  * position of a spinner is always at 256x192.
  */
 class Spinner extends HitObject {
+    get endTime() {
+        return this._endTime;
+    }
     constructor(values) {
         super(Object.assign(Object.assign({}, values), { position: new Vector2(256, 192) }));
+        this._endTime = values.endTime;
+    }
+    applySamples(controlPoints) {
+        super.applySamples(controlPoints);
+        this.auxiliarySamples.length = 0;
         const bankSample = this.samples.find((v) => v instanceof BankHitSampleInfo);
         if (bankSample) {
             this.auxiliarySamples.push(new BankHitSampleInfo("spinnerspin", bankSample.bank, bankSample.customSampleBank, bankSample.volume, bankSample.isLayered));
@@ -2279,7 +2395,7 @@ class Spinner extends HitObject {
         return this.position;
     }
     toString() {
-        return `Position: [${this.position.x}, ${this.position.y}], duration: ${this.duration}`;
+        return `Position: [${this._position.x}, ${this._position.y}], duration: ${this.duration}`;
     }
 }
 
@@ -2424,293 +2540,59 @@ class BeatmapHitObjects {
 }
 
 /**
- * Represents a beatmap with advanced information.
+ * Provides functionality to alter a beatmap after it has been converted.
  */
-class Beatmap {
-    constructor(shallowCopy) {
-        if (shallowCopy) {
-            this.formatVersion = shallowCopy.formatVersion;
-            this.general = shallowCopy.general;
-            this.editor = shallowCopy.editor;
-            this.metadata = shallowCopy.metadata;
-            this.difficulty = shallowCopy.difficulty;
-            this.events = shallowCopy.events;
-            this.controlPoints = shallowCopy.controlPoints;
-            this.colors = shallowCopy.colors;
-            this.hitObjects = shallowCopy.hitObjects;
-            return;
-        }
-        this.formatVersion = 1;
-        this.general = new BeatmapGeneral();
-        this.editor = new BeatmapEditor();
-        this.metadata = new BeatmapMetadata();
-        this.difficulty = new BeatmapDifficulty();
-        this.events = new BeatmapEvents();
-        this.controlPoints = new BeatmapControlPoints();
-        this.colors = new BeatmapColor();
-        this.hitObjects = new BeatmapHitObjects();
-    }
-    /**
-     * The maximum combo of the beatmap.
-     */
-    get maxCombo() {
-        return (this.hitObjects.circles +
-            this.hitObjects.sliders +
-            this.hitObjects.sliderTicks +
-            this.hitObjects.sliderRepeatPoints +
-            this.hitObjects.sliderEnds +
-            this.hitObjects.spinners);
-    }
-    /**
-     * The most common beat length of the beatmap.
-     */
-    get mostCommonBeatLength() {
-        var _a, _b, _c, _d, _e;
-        // The last playable time in the beatmap - the last timing point extends to this time.
-        // Note: This is more accurate and may present different results because osu-stable didn't have the ability to calculate slider durations in this context.
-        const lastTime = (_d = (_b = (_a = this.hitObjects.objects[this.hitObjects.objects.length - 1]) === null || _a === void 0 ? void 0 : _a.endTime) !== null && _b !== void 0 ? _b : (_c = this.controlPoints.timing.points[this.controlPoints.timing.points.length - 1]) === null || _c === void 0 ? void 0 : _c.time) !== null && _d !== void 0 ? _d : 0;
-        const mostCommon = 
-        // Construct a set of {beatLength, duration} objects for each individual timing point.
-        this.controlPoints.timing.points
-            .map((t, i, a) => {
-            if (t.time > lastTime) {
-                return { beatLength: t.msPerBeat, duration: 0 };
-            }
-            // osu-stable forced the first control point to start at 0.
-            const currentTime = i === 0 ? 0 : t.time;
-            const nextTime = i === a.length - 1 ? lastTime : a[i + 1].time;
-            return {
-                beatLength: t.msPerBeat,
-                duration: nextTime - currentTime,
-            };
-        })
-            // Get the most common one, or 0 as a suitable default.
-            .sort((a, b) => b.duration - a.duration)[0];
-        return (_e = mostCommon === null || mostCommon === void 0 ? void 0 : mostCommon.beatLength) !== null && _e !== void 0 ? _e : 0;
+class BeatmapProcessor {
+    constructor(beatmap) {
+        this.beatmap = beatmap;
     }
     /**
-     * Returns a time combined with beatmap-wide time offset.
+     * Processes the converted beatmap after `HitObject.applyDefaults` has been invoked.
      *
-     * BeatmapVersion 4 and lower had an incorrect offset. Stable has this set as 24ms off.
+     * Nested hitobjects generated during `HitObject.applyDefaults` wil be present by this point,
+     * and mods will have been applied to all hitobjects.
      *
-     * @param time The time.
-     */
-    getOffsetTime(time) {
-        return time + (this.formatVersion < 5 ? 24 : 0);
-    }
-    /**
-     * Calculates the osu!droid maximum score of the beatmap without taking spinner bonus into account.
+     * This should be used to add alterations to hitobjects while they are in their most playable state.
      *
-     * @param mods The modifications to calculate for. Defaults to No Mod.
-     * @param customSpeedMultiplier The custom speed multiplier of the beatmap. Defaults to 1.
+     * @param mode The mode to add alterations for.
      */
-    maxDroidScore(mods = [], customSpeedMultiplier = 1) {
-        let scoreMultiplier = 1;
-        for (const mod of mods) {
-            if (mod.isApplicableToDroid()) {
-                scoreMultiplier *= mod.droidScoreMultiplier;
-            }
+    postProcess(mode) {
+        const objects = this.beatmap.hitObjects.objects;
+        if (objects.length === 0) {
+            return;
         }
-        if (customSpeedMultiplier >= 1) {
-            scoreMultiplier *= 1 + (customSpeedMultiplier - 1) * 0.24;
+        // Reset stacking
+        objects.forEach((h) => {
+            h.stackHeight = 0;
+        });
+        switch (mode) {
+            case exports.Modes.droid:
+                this.applyDroidStacking();
+                break;
+            case exports.Modes.osu:
+                if (this.beatmap.formatVersion >= 6) {
+                    this.applyStandardStacking();
+                }
+                else {
+                    this.applyStandardOldStacking();
+                }
+                break;
         }
-        else {
-            scoreMultiplier *= Math.pow(0.3, (1 - customSpeedMultiplier) * 4);
+    }
+    applyDroidStacking() {
+        const objects = this.beatmap.hitObjects.objects;
+        if (objects.length === 0) {
+            return;
         }
-        const difficultyMultiplier = 1 +
-            this.difficulty.od / 10 +
-            this.difficulty.hp / 10 +
-            (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 { ticks } = object;
-            // Apply slider head.
-            score += 30;
-            ++combo;
-            // Apply slider repeats.
-            score += 30 * object.repeatCount;
-            combo += object.repeatCount;
-            // Apply slider ticks.
-            score += 10 * ticks;
-            combo += ticks;
-            // 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.
-     *
-     * @param mods The modifications to calculate for. Defaults to No Mod.
-     */
-    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;
-                break;
-            case accumulatedDiffPoints <= 12:
-                difficultyMultiplier = 3;
-                break;
-            case accumulatedDiffPoints <= 17:
-                difficultyMultiplier = 4;
-                break;
-            case accumulatedDiffPoints <= 24:
-                difficultyMultiplier = 5;
-                break;
-            case accumulatedDiffPoints >= 25:
-                difficultyMultiplier = 6;
-                break;
-        }
-        let combo = 0;
-        let score = 0;
-        for (const object of this.hitObjects.objects) {
-            if (!(object instanceof Slider)) {
-                score += Math.floor(300 +
-                    (300 * combo * difficultyMultiplier * scoreMultiplier) /
-                        25);
-                ++combo;
-                continue;
-            }
-            const { ticks } = object;
-            // Apply slider head.
-            score += 30;
-            ++combo;
-            // Apply slider repeats.
-            score += 30 * object.repeatCount;
-            combo += object.repeatCount;
-            // Apply slider ticks.
-            score += 10 * ticks;
-            combo += ticks;
-            // Apply slider end.
-            score += Math.floor(300 +
-                (300 * combo * difficultyMultiplier * scoreMultiplier) / 25);
-            ++combo;
-        }
-        return score;
-    }
-    /**
-     * Returns a string representative of the class.
-     */
-    toString() {
-        let res = this.metadata.artist + " - " + this.metadata.title + " [";
-        if (this.metadata.titleUnicode || this.metadata.artistUnicode) {
-            res +=
-                "(" +
-                    this.metadata.artistUnicode +
-                    " - " +
-                    this.metadata.titleUnicode +
-                    ")";
-        }
-        res +=
-            this.metadata.version +
-                "] mapped by " +
-                this.metadata.creator +
-                "\n" +
-                "\n" +
-                "AR" +
-                MathUtils.round(this.difficulty.ar, 2) +
-                " " +
-                "OD" +
-                MathUtils.round(this.difficulty.od, 2) +
-                " " +
-                "CS" +
-                MathUtils.round(this.difficulty.cs, 2) +
-                " " +
-                "HP" +
-                MathUtils.round(this.difficulty.hp, 2) +
-                "\n" +
-                this.hitObjects.circles +
-                " circles, " +
-                this.hitObjects.sliders +
-                " sliders, " +
-                this.hitObjects.spinners +
-                " spinners" +
-                "\n" +
-                this.maxCombo +
-                " max combo";
-        return res;
-    }
-}
-
-/**
- * Represents a beatmap's background.
- */
-class BeatmapBackground {
-    constructor(filename, offset) {
-        this.filename = filename;
-        this.offset = offset;
-    }
-}
-
-/**
- * Provides functionality to alter a beatmap after it has been converted.
- */
-class BeatmapProcessor {
-    constructor(beatmap) {
-        this.beatmap = beatmap;
-    }
-    /**
-     * Processes the converted beatmap after `HitObject.applyDefaults` has been invoked.
-     *
-     * Nested hitobjects generated during `HitObject.applyDefaults` wil be present by this point,
-     * and mods will have been applied to all hitobjects.
-     *
-     * This should be used to add alterations to hitobjects while they are in their most playable state.
-     *
-     * @param mode The mode to add alterations for.
-     */
-    postProcess(mode) {
-        const objects = this.beatmap.hitObjects.objects;
-        if (objects.length === 0) {
-            return;
-        }
-        // Reset stacking
-        objects.forEach((h) => {
-            h.stackHeight = 0;
-        });
-        switch (mode) {
-            case exports.Modes.droid:
-                this.applyDroidStacking();
-                break;
-            case exports.Modes.osu:
-                if (this.beatmap.formatVersion >= 6) {
-                    this.applyStandardStacking();
-                }
-                else {
-                    this.applyStandardOldStacking();
-                }
-                break;
-        }
-    }
-    applyDroidStacking() {
-        const objects = this.beatmap.hitObjects.objects;
-        if (objects.length === 0) {
-            return;
-        }
-        const convertedScale = CircleSizeCalculator.standardScaleToDroidScale(objects[0].scale);
-        for (let i = 0; i < objects.length - 1; ++i) {
-            const current = objects[i];
-            const next = objects[i + 1];
-            if (next.startTime - current.startTime <
-                2000 * this.beatmap.general.stackLeniency &&
-                next.position.getDistance(current.position) <
-                    Math.sqrt(convertedScale)) {
-                next.stackHeight = current.stackHeight + 1;
+        const convertedScale = CircleSizeCalculator.standardScaleToDroidScale(objects[0].scale);
+        for (let i = 0; i < objects.length - 1; ++i) {
+            const current = objects[i];
+            const next = objects[i + 1];
+            if (next.startTime - current.startTime <
+                2000 * this.beatmap.general.stackLeniency &&
+                next.position.getDistance(current.position) <
+                    Math.sqrt(convertedScale)) {
+                next.stackHeight = current.stackHeight + 1;
             }
         }
     }
@@ -2843,70 +2725,312 @@ class BeatmapProcessor {
             }
         }
     }
-    applyStandardOldStacking() {
-        const objects = this.beatmap.hitObjects.objects;
-        for (let i = 0; i < objects.length; ++i) {
-            const currentObject = objects[i];
-            if (currentObject.stackHeight !== 0 &&
-                !(currentObject instanceof Slider)) {
-                continue;
+    applyStandardOldStacking() {
+        const objects = this.beatmap.hitObjects.objects;
+        for (let i = 0; i < objects.length; ++i) {
+            const currentObject = objects[i];
+            if (currentObject.stackHeight !== 0 &&
+                !(currentObject instanceof Slider)) {
+                continue;
+            }
+            let startTime = currentObject.endTime;
+            let sliderStack = 0;
+            const stackThreshold = currentObject.timePreempt * this.beatmap.general.stackLeniency;
+            for (let j = i + 1; j < objects.length; ++j) {
+                if (objects[j].startTime - stackThreshold > startTime) {
+                    break;
+                }
+                // Note the use of `startTime` in the code below doesn't match osu!stable's use of `endTime`.
+                // This is because in osu!stable's implementation, `UpdateCalculations` is not called on the inner-loop hitobject (j)
+                // and therefore it does not have a correct `endTime`, but instead the default of `endTime = startTime`.
+                //
+                // Effects of this can be seen on https://osu.ppy.sh/beatmapsets/243#osu/1146 at sliders around 86647 ms, where
+                // if we use `endTime` here it would result in unexpected stacking.
+                //
+                // Reference: https://github.com/ppy/osu/pull/24188
+                if (objects[j].position.getDistance(currentObject.position) <
+                    BeatmapProcessor.stackDistance) {
+                    ++currentObject.stackHeight;
+                    startTime = objects[j].startTime;
+                }
+                else if (objects[j].position.getDistance(currentObject.endPosition) <
+                    BeatmapProcessor.stackDistance) {
+                    // Case for sliders - bump notes down and right, rather than up and left.
+                    ++sliderStack;
+                    objects[j].stackHeight -= sliderStack;
+                    startTime = objects[j].startTime;
+                }
+            }
+        }
+    }
+}
+BeatmapProcessor.stackDistance = 3;
+
+/**
+ * Converts a beatmap for another mode.
+ */
+class BeatmapConverter {
+    constructor(beatmap) {
+        this.beatmap = beatmap;
+    }
+    /**
+     * Converts the beatmap.
+     *
+     * @returns The converted beatmap.
+     */
+    convert() {
+        const converted = new Beatmap(this.beatmap);
+        // Shallow clone isn't enough to ensure we don't mutate some beatmap properties unexpectedly.
+        converted.difficulty = new BeatmapDifficulty(this.beatmap.difficulty);
+        converted.hitObjects = this.convertHitObjects();
+        return converted;
+    }
+    convertHitObjects() {
+        const hitObjects = new BeatmapHitObjects();
+        this.beatmap.hitObjects.objects.forEach((hitObject) => {
+            hitObjects.add(this.convertHitObject(hitObject));
+        });
+        return hitObjects;
+    }
+    convertHitObject(hitObject) {
+        let object;
+        if (hitObject instanceof Circle) {
+            object = new Circle({
+                startTime: hitObject.startTime,
+                position: hitObject.position,
+                newCombo: hitObject.isNewCombo,
+                type: hitObject.type,
+                comboOffset: hitObject.comboOffset,
+            });
+        }
+        else if (hitObject instanceof Slider) {
+            object = new Slider({
+                startTime: hitObject.startTime,
+                position: hitObject.position,
+                newCombo: hitObject.isNewCombo,
+                type: hitObject.type,
+                path: hitObject.path,
+                repeatCount: hitObject.repeatCount,
+                nodeSamples: hitObject.nodeSamples,
+                comboOffset: hitObject.comboOffset,
+                tickDistanceMultiplier: 
+                // 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.beatmap.formatVersion < 8
+                    ? 1 /
+                        this.beatmap.controlPoints.difficulty.controlPointAt(hitObject.startTime).speedMultiplier
+                    : 1,
+            });
+        }
+        else {
+            object = new Spinner({
+                startTime: hitObject.startTime,
+                endTime: hitObject.endTime,
+                type: hitObject.type,
+            });
+        }
+        object.samples = hitObject.samples;
+        object.auxiliarySamples = hitObject.auxiliarySamples;
+        return object;
+    }
+}
+
+/**
+ * Represents a beatmap with advanced information.
+ */
+class Beatmap {
+    constructor(shallowCopy) {
+        if (shallowCopy) {
+            this.formatVersion = shallowCopy.formatVersion;
+            this.general = shallowCopy.general;
+            this.editor = shallowCopy.editor;
+            this.metadata = shallowCopy.metadata;
+            this.difficulty = shallowCopy.difficulty;
+            this.events = shallowCopy.events;
+            this.controlPoints = shallowCopy.controlPoints;
+            this.colors = shallowCopy.colors;
+            this.hitObjects = shallowCopy.hitObjects;
+            return;
+        }
+        this.formatVersion = 1;
+        this.general = new BeatmapGeneral();
+        this.editor = new BeatmapEditor();
+        this.metadata = new BeatmapMetadata();
+        this.difficulty = new BeatmapDifficulty();
+        this.events = new BeatmapEvents();
+        this.controlPoints = new BeatmapControlPoints();
+        this.colors = new BeatmapColor();
+        this.hitObjects = new BeatmapHitObjects();
+    }
+    /**
+     * The maximum combo of the beatmap.
+     */
+    get maxCombo() {
+        return (this.hitObjects.circles +
+            this.hitObjects.sliders +
+            this.hitObjects.sliderTicks +
+            this.hitObjects.sliderRepeatPoints +
+            this.hitObjects.sliderEnds +
+            this.hitObjects.spinners);
+    }
+    /**
+     * The most common beat length of the beatmap.
+     */
+    get mostCommonBeatLength() {
+        var _a, _b, _c, _d, _e;
+        // The last playable time in the beatmap - the last timing point extends to this time.
+        // Note: This is more accurate and may present different results because osu-stable didn't have the ability to calculate slider durations in this context.
+        const lastTime = (_d = (_b = (_a = this.hitObjects.objects[this.hitObjects.objects.length - 1]) === null || _a === void 0 ? void 0 : _a.endTime) !== null && _b !== void 0 ? _b : (_c = this.controlPoints.timing.points[this.controlPoints.timing.points.length - 1]) === null || _c === void 0 ? void 0 : _c.time) !== null && _d !== void 0 ? _d : 0;
+        const mostCommon = 
+        // Construct a set of {beatLength, duration} objects for each individual timing point.
+        this.controlPoints.timing.points
+            .map((t, i, a) => {
+            if (t.time > lastTime) {
+                return { beatLength: t.msPerBeat, duration: 0 };
+            }
+            // osu-stable forced the first control point to start at 0.
+            const currentTime = i === 0 ? 0 : t.time;
+            const nextTime = i === a.length - 1 ? lastTime : a[i + 1].time;
+            return {
+                beatLength: t.msPerBeat,
+                duration: nextTime - currentTime,
+            };
+        })
+            // Get the most common one, or 0 as a suitable default.
+            .sort((a, b) => b.duration - a.duration)[0];
+        return (_e = mostCommon === null || mostCommon === void 0 ? void 0 : mostCommon.beatLength) !== null && _e !== void 0 ? _e : 0;
+    }
+    /**
+     * Returns a time combined with beatmap-wide time offset.
+     *
+     * BeatmapVersion 4 and lower had an incorrect offset. Stable has this set as 24ms off.
+     *
+     * @param time The time.
+     */
+    getOffsetTime(time) {
+        return time + (this.formatVersion < 5 ? 24 : 0);
+    }
+    /**
+     * Calculates the osu!droid maximum score of the beatmap without taking spinner bonus into account.
+     *
+     * @param mods The modifications to calculate for. Defaults to No Mod.
+     * @param customSpeedMultiplier The custom speed multiplier of the beatmap. Defaults to 1.
+     */
+    maxDroidScore(mods = [], customSpeedMultiplier = 1) {
+        let scoreMultiplier = 1;
+        for (const mod of mods) {
+            if (mod.isApplicableToDroid()) {
+                scoreMultiplier *= mod.droidScoreMultiplier;
+            }
+        }
+        if (customSpeedMultiplier >= 1) {
+            scoreMultiplier *= 1 + (customSpeedMultiplier - 1) * 0.24;
+        }
+        else {
+            scoreMultiplier *= Math.pow(0.3, (1 - customSpeedMultiplier) * 4);
+        }
+        const difficultyMultiplier = 1 +
+            this.difficulty.od / 10 +
+            this.difficulty.hp / 10 +
+            (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 { ticks } = object;
+            // Apply slider head.
+            score += 30;
+            ++combo;
+            // Apply slider repeats.
+            score += 30 * object.repeatCount;
+            combo += object.repeatCount;
+            // Apply slider ticks.
+            score += 10 * ticks;
+            combo += ticks;
+            // 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.
+     *
+     * @param mods The modifications to calculate for. Defaults to No Mod.
+     */
+    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;
             }
-            let startTime = currentObject.endTime;
-            let sliderStack = 0;
-            const stackThreshold = currentObject.timePreempt * this.beatmap.general.stackLeniency;
-            for (let j = i + 1; j < objects.length; ++j) {
-                if (objects[j].startTime - stackThreshold > startTime) {
-                    break;
-                }
-                // Note the use of `startTime` in the code below doesn't match osu!stable's use of `endTime`.
-                // This is because in osu!stable's implementation, `UpdateCalculations` is not called on the inner-loop hitobject (j)
-                // and therefore it does not have a correct `endTime`, but instead the default of `endTime = startTime`.
-                //
-                // Effects of this can be seen on https://osu.ppy.sh/beatmapsets/243#osu/1146 at sliders around 86647 ms, where
-                // if we use `endTime` here it would result in unexpected stacking.
-                //
-                // Reference: https://github.com/ppy/osu/pull/24188
-                if (objects[j].position.getDistance(currentObject.position) <
-                    BeatmapProcessor.stackDistance) {
-                    ++currentObject.stackHeight;
-                    startTime = objects[j].startTime;
-                }
-                else if (objects[j].position.getDistance(currentObject.endPosition) <
-                    BeatmapProcessor.stackDistance) {
-                    // Case for sliders - bump notes down and right, rather than up and left.
-                    ++sliderStack;
-                    objects[j].stackHeight -= sliderStack;
-                    startTime = objects[j].startTime;
-                }
+        }
+        switch (true) {
+            case accumulatedDiffPoints <= 5:
+                difficultyMultiplier = 2;
+                break;
+            case accumulatedDiffPoints <= 12:
+                difficultyMultiplier = 3;
+                break;
+            case accumulatedDiffPoints <= 17:
+                difficultyMultiplier = 4;
+                break;
+            case accumulatedDiffPoints <= 24:
+                difficultyMultiplier = 5;
+                break;
+            case accumulatedDiffPoints >= 25:
+                difficultyMultiplier = 6;
+                break;
+        }
+        let combo = 0;
+        let score = 0;
+        for (const object of this.hitObjects.objects) {
+            if (!(object instanceof Slider)) {
+                score += Math.floor(300 +
+                    (300 * combo * difficultyMultiplier * scoreMultiplier) /
+                        25);
+                ++combo;
+                continue;
             }
+            const { ticks } = object;
+            // Apply slider head.
+            score += 30;
+            ++combo;
+            // Apply slider repeats.
+            score += 30 * object.repeatCount;
+            combo += object.repeatCount;
+            // Apply slider ticks.
+            score += 10 * ticks;
+            combo += ticks;
+            // Apply slider end.
+            score += Math.floor(300 +
+                (300 * combo * difficultyMultiplier * scoreMultiplier) / 25);
+            ++combo;
         }
-    }
-}
-BeatmapProcessor.stackDistance = 3;
-
-/**
- * Converts a beatmap for another mode.
- */
-class BeatmapConverter {
-    constructor(beatmap) {
-        this.beatmap = beatmap;
+        return score;
     }
     /**
-     * Converts the beatmap.
+     * Constructs a playable `Beatmap` from this `Beatmap`.
      *
-     * @param options The options to use for conversion.
-     * @returns The converted beatmap.
+     * The returned `Beatmap` is in a playable state - all `HitObject` and `BeatmapDifficulty` `Mod`s
+     * have been applied, and `HitObject`s have been fully constructed.
+     *
+     * @param options The options to use.
+     * @return The constructed `Beatmap`.
      */
-    convert(options) {
+    createPlayableBeatmap(options) {
         var _a, _b, _c;
         const mods = (_a = options === null || options === void 0 ? void 0 : options.mods) !== null && _a !== void 0 ? _a : [];
         const mode = (_b = options === null || options === void 0 ? void 0 : options.mode) !== null && _b !== void 0 ? _b : exports.Modes.osu;
         const customSpeedMultiplier = (_c = options === null || options === void 0 ? void 0 : options.customSpeedMultiplier) !== null && _c !== void 0 ? _c : 1;
         // Convert
-        const converted = new Beatmap(this.beatmap);
-        // Shallow clone isn't enough to ensure we don't mutate some beatmap properties unexpectedly.
-        converted.difficulty = new BeatmapDifficulty(this.beatmap.difficulty);
-        converted.hitObjects = this.convertHitObjects();
+        const converted = new BeatmapConverter(this).convert();
         // Apply difficulty mods
         mods.forEach((mod) => {
             if (mod.isApplicableToDifficulty()) {
@@ -2921,7 +3045,6 @@ class BeatmapConverter {
                 mod.applyToDifficultyWithSettings(mode, converted.difficulty, mods, customSpeedMultiplier);
             }
         });
-        const processor = new BeatmapProcessor(converted);
         // Compute default values for hit objects, including creating nested hit objects in-case they're needed.
         converted.hitObjects.objects.forEach((hitObject) => hitObject.applyDefaults(converted.controlPoints, converted.difficulty, mode));
         mods.forEach((mod) => {
@@ -2931,7 +3054,7 @@ class BeatmapConverter {
                 }
             }
         });
-        processor.postProcess(mode);
+        new BeatmapProcessor(converted).postProcess(mode);
         mods.forEach((mod) => {
             if (mod.isApplicableToBeatmap()) {
                 mod.applyToBeatmap(converted);
@@ -2939,52 +3062,57 @@ class BeatmapConverter {
         });
         return converted;
     }
-    convertHitObjects() {
-        const hitObjects = new BeatmapHitObjects();
-        this.beatmap.hitObjects.objects.forEach((hitObject) => {
-            hitObjects.add(this.convertHitObject(hitObject));
-        });
-        return hitObjects;
-    }
-    convertHitObject(hitObject) {
-        let object;
-        if (hitObject instanceof Circle) {
-            object = new Circle({
-                startTime: hitObject.startTime,
-                position: hitObject.position,
-                newCombo: hitObject.isNewCombo,
-                type: hitObject.type,
-                comboOffset: hitObject.comboOffset,
-            });
-        }
-        else if (hitObject instanceof Slider) {
-            object = new Slider({
-                startTime: hitObject.startTime,
-                position: hitObject.position,
-                newCombo: hitObject.isNewCombo,
-                type: hitObject.type,
-                path: hitObject.path,
-                repeatCount: hitObject.repeatCount,
-                nodeSamples: hitObject.nodeSamples,
-                comboOffset: hitObject.comboOffset,
-                tickDistanceMultiplier: 
-                // 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.beatmap.formatVersion < 8
-                    ? 1 /
-                        this.beatmap.controlPoints.difficulty.controlPointAt(hitObject.startTime).speedMultiplier
-                    : 1,
-            });
-        }
-        else {
-            object = new Spinner({
-                startTime: hitObject.startTime,
-                endTime: hitObject.endTime,
-                type: hitObject.type,
-            });
+    /**
+     * Returns a string representative of the class.
+     */
+    toString() {
+        let res = this.metadata.artist + " - " + this.metadata.title + " [";
+        if (this.metadata.titleUnicode || this.metadata.artistUnicode) {
+            res +=
+                "(" +
+                    this.metadata.artistUnicode +
+                    " - " +
+                    this.metadata.titleUnicode +
+                    ")";
         }
-        object.samples = hitObject.samples;
-        return object;
+        res +=
+            this.metadata.version +
+                "] mapped by " +
+                this.metadata.creator +
+                "\n" +
+                "\n" +
+                "AR" +
+                MathUtils.round(this.difficulty.ar, 2) +
+                " " +
+                "OD" +
+                MathUtils.round(this.difficulty.od, 2) +
+                " " +
+                "CS" +
+                MathUtils.round(this.difficulty.cs, 2) +
+                " " +
+                "HP" +
+                MathUtils.round(this.difficulty.hp, 2) +
+                "\n" +
+                this.hitObjects.circles +
+                " circles, " +
+                this.hitObjects.sliders +
+                " sliders, " +
+                this.hitObjects.spinners +
+                " spinners" +
+                "\n" +
+                this.maxCombo +
+                " max combo";
+        return res;
+    }
+}
+
+/**
+ * Represents a beatmap's background.
+ */
+class BeatmapBackground {
+    constructor(filename, offset) {
+        this.filename = filename;
+        this.offset = offset;
     }
 }
 
@@ -7404,6 +7532,20 @@ class Interpolation {
     }
 }
 
+/**
+ * Ranking status of a beatmap.
+ */
+exports.RankedStatus = void 0;
+(function (RankedStatus) {
+    RankedStatus[RankedStatus["graveyard"] = -2] = "graveyard";
+    RankedStatus[RankedStatus["wip"] = -1] = "wip";
+    RankedStatus[RankedStatus["pending"] = 0] = "pending";
+    RankedStatus[RankedStatus["ranked"] = 1] = "ranked";
+    RankedStatus[RankedStatus["approved"] = 2] = "approved";
+    RankedStatus[RankedStatus["qualified"] = 3] = "qualified";
+    RankedStatus[RankedStatus["loved"] = 4] = "loved";
+})(exports.RankedStatus || (exports.RankedStatus = {}));
+
 /**
  * An API request builder for osu!standard.
  */
@@ -7448,7 +7590,7 @@ class MapInfo {
         /**
          * The ranking status of the beatmap.
          */
-        this.approved = 0;
+        this.approved = exports.RankedStatus.pending;
         /**
          * The ID of the beatmap.
          */
@@ -7520,7 +7662,7 @@ class MapInfo {
         /**
          * The maximum combo of the beatmap.
          */
-        this.maxCombo = 0;
+        this.maxCombo = null;
         /**
          * The circle size of the beatmap.
          */
@@ -7676,7 +7818,8 @@ class MapInfo {
         map.spinners = mapinfo.count_spinner
             ? parseInt(mapinfo.count_spinner)
             : 0;
-        map.maxCombo = parseInt(mapinfo.max_combo);
+        map.maxCombo =
+            mapinfo.max_combo !== null ? parseInt(mapinfo.max_combo) : null;
         map.cs = parseFloat(mapinfo.diff_size);
         map.ar = parseFloat(mapinfo.diff_approach);
         map.od = parseFloat(mapinfo.diff_overall);
@@ -7707,7 +7850,7 @@ class MapInfo {
      * @returns The raw API response represented by this `MapInfo`.
      */
     toAPIResponse() {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         const padDateNumber = (num) => num.toString().padStart(2, "0");
         const convertDate = (date) => `${date.getUTCFullYear()}-${padDateNumber(date.getUTCMonth() + 1)}-${padDateNumber(date.getUTCDate())} ${padDateNumber(date.getUTCHours())}:${padDateNumber(date.getUTCMinutes())}:${padDateNumber(date.getUTCSeconds())}`;
         return {
@@ -7748,7 +7891,7 @@ class MapInfo {
             count_normal: this.circles.toString(),
             count_slider: this.sliders.toString(),
             count_spinner: this.spinners.toString(),
-            max_combo: this.maxCombo.toString(),
+            max_combo: (_h = (_g = this.maxCombo) === null || _g === void 0 ? void 0 : _g.toString()) !== null && _h !== void 0 ? _h : null,
             storyboard: this.storyboardAvailable ? "1" : "0",
             video: this.videoAvailable ? "1" : "0",
             download_unavailable: this.downloadAvailable ? "0" : "1",
@@ -7882,6 +8025,16 @@ class ModFlashlight extends Mod {
     }
 }
 
+/**
+ * Represents the osu! playfield.
+ */
+class Playfield {
+}
+/**
+ * The size of the playfield, which is 512x384.
+ */
+Playfield.baseSize = new Vector2(512, 384);
+
 /**
  * Represents the HardRock mod.
  */
@@ -7914,6 +8067,29 @@ class ModHardRock extends Mod {
         difficulty.od = this.applySetting(difficulty.od);
         difficulty.hp = this.applySetting(difficulty.hp);
     }
+    applyToHitObject(_, hitObject) {
+        // Reflect the position of the hit object.
+        hitObject.position = this.reflectVector(hitObject.position);
+        if (!(hitObject instanceof Slider)) {
+            return;
+        }
+        // Reflect the control points of the slider. This will reflect the positions of head and tail circles.
+        hitObject.path = new SliderPath({
+            pathType: hitObject.path.pathType,
+            controlPoints: hitObject.path.controlPoints.map((v) => this.reflectControlPoint(v)),
+            expectedDistance: hitObject.path.expectedDistance,
+        });
+        // Reflect the position of slider ticks and repeats.
+        hitObject.nestedHitObjects.forEach((obj) => {
+            obj.position = this.reflectVector(obj.position);
+        });
+    }
+    reflectVector(vector) {
+        return new Vector2(vector.x, Playfield.baseSize.y - vector.y);
+    }
+    reflectControlPoint(vector) {
+        return new Vector2(vector.x, -vector.y);
+    }
     applySetting(value, ratio = 1.4) {
         return Math.min(value * ratio, 10);
     }
@@ -8341,30 +8517,6 @@ class NormalDistribution {
     }
 }
 
-/**
- * Represents the osu! playfield.
- */
-class Playfield {
-}
-/**
- * The size of the playfield, which is 512x384.
- */
-Playfield.baseSize = new Vector2(512, 384);
-
-/**
- * Ranking status of a beatmap.
- */
-exports.RankedStatus = void 0;
-(function (RankedStatus) {
-    RankedStatus[RankedStatus["graveyard"] = -2] = "graveyard";
-    RankedStatus[RankedStatus["wip"] = -1] = "wip";
-    RankedStatus[RankedStatus["pending"] = 0] = "pending";
-    RankedStatus[RankedStatus["ranked"] = 1] = "ranked";
-    RankedStatus[RankedStatus["approved"] = 2] = "approved";
-    RankedStatus[RankedStatus["qualified"] = 3] = "qualified";
-    RankedStatus[RankedStatus["loved"] = 4] = "loved";
-})(exports.RankedStatus || (exports.RankedStatus = {}));
-
 dotenv.config();
 
 exports.AR0_MS = AR0_MS;