@rian8337/osu-droid-replay-analyzer 4.0.0-beta.53 → 4.0.0-beta.55

package/dist/index.js

@@ -1,11 +1,9 @@
 'use strict';
 
 var osuBase = require('@rian8337/osu-base');
-var osuDifficultyCalculator = require('@rian8337/osu-difficulty-calculator');
-var osuRebalanceDifficultyCalculator = require('@rian8337/osu-rebalance-difficulty-calculator');
-var unzipper = require('unzipper');
 var javaDeserialization = require('java-deserialization');
 var node_stream = require('node:stream');
+var unzipper = require('unzipper');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -747,42 +745,223 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 /**
- * Represents a replay data in an osu!droid replay version 1 and 2.
- *
- * Stores generic information about an osu!droid replay.
- *
- * This is used when analyzing replays using replay analyzer.
+ * Utility to check whether relevant sliders in a beatmap are cheesed.
  */
-class ReplayData {
-    constructor(values) {
-        this.replayVersion = values.replayVersion;
-        this.folderName = values.folderName;
-        this.fileName = values.fileName;
-        this.hash = values.hash;
-        this.accuracy = values.accuracy;
-        this.rank = values.rank;
-        this.hit300k = values.hit300k;
-        this.hit100k = values.hit100k;
-        this.cursorMovement = values.cursorMovement;
-        this.hitObjectData = values.hitObjectData;
+class SliderCheeseChecker {
+    /**
+     * @param beatmap The beatmap to analyze.
+     * @param data The data of the replay.
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
+     */
+    constructor(beatmap, data, difficultyAttributes) {
+        this.beatmap = beatmap;
+        this.data = data;
+        this.difficultyAttributes = difficultyAttributes;
+        this.hitWindow50 = difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise)
+            ? new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od).mehWindow
+            : new osuBase.DroidHitWindow(beatmap.difficulty.od).mehWindow;
+        this.isHardRock = difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHardRock);
     }
     /**
-     * Whether the replay's version is 3 or later.
+     * Checks if relevant sliders in the given beatmap was cheesed.
      */
-    isReplayV3() {
-        return this.replayVersion >= 3;
+    check() {
+        if (this.difficultyAttributes.difficultSliders.length === 0 ||
+            (this.difficultyAttributes.sliderFactor === 1 &&
+                this.difficultyAttributes.flashlightSliderFactor === 1 &&
+                this.difficultyAttributes.visualSliderFactor === 1)) {
+            return {
+                aimPenalty: 1,
+                flashlightPenalty: 1,
+                visualPenalty: 1,
+            };
+        }
+        const cheesedDifficultyRatings = this.checkSliderCheesing();
+        return this.calculateSliderCheesePenalty(cheesedDifficultyRatings);
     }
     /**
-     * Whether the replay's version is 4 or later.
+     * Checks for sliders that were cheesed.
      */
-    isReplayV4() {
-        return this.replayVersion >= 4;
+    checkSliderCheesing() {
+        const { objects } = this.beatmap.hitObjects;
+        const cheesedDifficultyRatings = [];
+        // Current loop indices are stored for efficiency.
+        const cursorLoopIndices = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
+        const acceptableRadius = objects[0].radius * 2;
+        // Sort difficult sliders by index so that cursor loop indices work properly.
+        for (const difficultSlider of this.difficultyAttributes.difficultSliders
+            .slice()
+            .sort((a, b) => a.index - b.index)) {
+            if (difficultSlider.index >= this.data.hitObjectData.length) {
+                continue;
+            }
+            const object = objects[difficultSlider.index];
+            const objectData = this.data.hitObjectData[difficultSlider.index];
+            // If a miss or slider break occurs, we disregard the check for that slider.
+            if (objectData.result === exports.HitResult.miss ||
+                -this.hitWindow50 > objectData.accuracy ||
+                objectData.accuracy >
+                    Math.min(this.hitWindow50, object.duration)) {
+                continue;
+            }
+            const objectStartPosition = object.getStackedPosition(osuBase.Modes.droid);
+            // These time boundaries should consider the delta time between the previous and next
+            // object as well as their hit accuracy. However, they are somewhat complicated to
+            // compute and the accuracy gain is small. As such, let's settle with 50 hit window.
+            const minTimeLimit = object.startTime - this.hitWindow50;
+            const maxTimeLimit = object.startTime + this.hitWindow50;
+            // Get the closest tap distance across all cursors.
+            const closestDistances = [];
+            const closestGroupIndices = [];
+            for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+                const cursorGroups = this.data.cursorMovement[i].occurrenceGroups;
+                let closestDistance = Number.POSITIVE_INFINITY;
+                let closestIndex = cursorGroups.length;
+                for (let j = cursorLoopIndices[i]; j < cursorGroups.length; j = ++cursorLoopIndices[i]) {
+                    const group = cursorGroups[j];
+                    if (group.endTime < minTimeLimit) {
+                        continue;
+                    }
+                    if (group.startTime > maxTimeLimit) {
+                        break;
+                    }
+                    if (group.startTime >= minTimeLimit) {
+                        const position = this.getCursorPosition(group.down);
+                        const distance = position.getDistance(objectStartPosition);
+                        if (closestDistance > distance) {
+                            closestDistance = distance;
+                            closestIndex = j;
+                        }
+                        if (closestDistance <= acceptableRadius / 2) {
+                            break;
+                        }
+                    }
+                    // Normally, we check if there are cursor presses within the group's active time.
+                    // However, some funky workarounds are used throughout the game for replays, so
+                    // for the time being we only check for cursor distances across the group.
+                    const { allOccurrences } = group;
+                    for (let k = 1; k < allOccurrences.length; ++k) {
+                        const cursor = allOccurrences[k];
+                        const prevCursor = allOccurrences[k - 1];
+                        let distance = Number.POSITIVE_INFINITY;
+                        const currentPosition = this.getCursorPosition(cursor);
+                        const prevPosition = this.getCursorPosition(prevCursor);
+                        switch (cursor.id) {
+                            case exports.MovementType.up:
+                                distance =
+                                    prevPosition.getDistance(objectStartPosition);
+                                break;
+                            case exports.MovementType.move:
+                                for (let mSecPassed = Math.max(prevCursor.time, minTimeLimit); mSecPassed <=
+                                    Math.min(cursor.time, maxTimeLimit); ++mSecPassed) {
+                                    const t = (mSecPassed - prevCursor.time) /
+                                        (cursor.time - prevCursor.time);
+                                    const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                                    distance =
+                                        cursorPosition.getDistance(objectStartPosition);
+                                    if (closestDistance > distance) {
+                                        closestDistance = distance;
+                                        closestIndex = j;
+                                    }
+                                    if (closestDistance <=
+                                        acceptableRadius / 2) {
+                                        break;
+                                    }
+                                }
+                        }
+                        if (closestDistance > distance) {
+                            closestDistance = distance;
+                            closestIndex = j;
+                        }
+                        if (closestDistance <= acceptableRadius / 2) {
+                            break;
+                        }
+                    }
+                }
+                closestDistances.push(closestDistance);
+                closestGroupIndices.push(closestIndex);
+                if (cursorLoopIndices[i] > 0) {
+                    // Decrement the index. The previous group may also have a role on the next slider.
+                    --cursorLoopIndices[i];
+                }
+            }
+            const cursorIndex = closestDistances.indexOf(Math.min(...closestDistances));
+            const closestDistance = closestDistances[cursorIndex];
+            if (closestDistance > acceptableRadius / 2) {
+                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
+                continue;
+            }
+            const group = this.data.cursorMovement[cursorIndex].occurrenceGroups[closestGroupIndices[cursorIndex]];
+            let isCheesed = false;
+            // Track cursor movement to see if it lands on every tick.
+            let occurrenceLoopIndex = 1;
+            const { allOccurrences } = group;
+            for (let i = 1; i < object.nestedHitObjects.length; ++i) {
+                if (isCheesed) {
+                    break;
+                }
+                const tickWasHit = objectData.tickset[i - 1];
+                if (!tickWasHit) {
+                    continue;
+                }
+                const nestedObject = object.nestedHitObjects[i];
+                const nestedPosition = nestedObject.getStackedPosition(osuBase.Modes.droid);
+                while (occurrenceLoopIndex < allOccurrences.length &&
+                    allOccurrences[occurrenceLoopIndex].time <
+                        nestedObject.startTime) {
+                    ++occurrenceLoopIndex;
+                }
+                if (occurrenceLoopIndex === allOccurrences.length) {
+                    continue;
+                }
+                const cursor = allOccurrences[occurrenceLoopIndex];
+                const prevCursor = allOccurrences[occurrenceLoopIndex - 1];
+                const currentPosition = this.getCursorPosition(cursor);
+                const prevPosition = this.getCursorPosition(prevCursor);
+                switch (cursor.id) {
+                    case exports.MovementType.move: {
+                        // Interpolate cursor position during nested object time.
+                        const t = (nestedObject.startTime - prevCursor.time) /
+                            (cursor.time - prevCursor.time);
+                        const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                        const distance = cursorPosition.getDistance(nestedPosition);
+                        isCheesed = distance > acceptableRadius;
+                        break;
+                    }
+                    case exports.MovementType.up:
+                        isCheesed =
+                            prevPosition.getDistance(nestedPosition) >
+                                acceptableRadius;
+                }
+            }
+            if (isCheesed) {
+                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
+            }
+        }
+        return cheesedDifficultyRatings;
     }
     /**
-     * Whether the replay's version is 5 or later.
+     * Calculates the slider cheese penalty.
      */
-    isReplayV5() {
-        return this.replayVersion >= 5;
+    calculateSliderCheesePenalty(cheesedDifficultyRatings) {
+        const summedDifficultyRating = Math.min(1, cheesedDifficultyRatings.reduce((a, v) => a + v, 0));
+        return {
+            aimPenalty: Math.max(this.difficultyAttributes.sliderFactor, Math.pow(1 -
+                summedDifficultyRating *
+                    this.difficultyAttributes.sliderFactor, 2)),
+            flashlightPenalty: Math.max(this.difficultyAttributes.flashlightSliderFactor, Math.pow(1 -
+                summedDifficultyRating *
+                    this.difficultyAttributes.flashlightSliderFactor, 2)),
+            visualPenalty: Math.max(this.difficultyAttributes.visualSliderFactor, Math.pow(1 -
+                summedDifficultyRating *
+                    this.difficultyAttributes.visualSliderFactor, 2)),
+        };
+    }
+    getCursorPosition(cursor) {
+        if (this.isHardRock) {
+            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
+        }
+        return cursor.position;
     }
 }
 
@@ -1188,7 +1367,7 @@ class ThreeFingerChecker {
  */
 class IndexedHitObject {
     /**
-     * @param object The underlying difficulty hitobject.
+     * @param object The underlying hitobject.
      * @param cursorIndex The cursor index that moves towards the hitobject.
      * @param groupIndex The group index of the cursor within the cursor index that hits the hitobject.
      * @param occurrenceIndex The occurrence index within the group of the cursor within the cursor index that hits the hitobject.
@@ -1205,7 +1384,7 @@ class IndexedHitObject {
         this.occurrenceIndex = occurrenceIndex;
         this.angle = angle;
         this.is2Handed = is2Handed;
-        this.endCursorPosition = this.object.object.getStackedEndPosition(osuBase.Modes.droid);
+        this.endCursorPosition = this.object.getStackedEndPosition(osuBase.Modes.droid);
     }
 }
 
@@ -1216,22 +1395,24 @@ class IndexedHitObject {
 class TwoHandChecker {
     // private csvString: string;
     /**
-     * @param calculator The difficulty calculator to analyze.
+     * @param beatmap The beatmap to analyze.
+     * @param attributes The difficulty attributes to analyze.
      * @param data The data of the replay.
      */
-    constructor(calculator, data) {
+    constructor(beatmap, attributes, data) {
         /**
          * The hitobjects of the beatmap that have been assigned with their respective cursor index.
          */
         this.indexedHitObjects = [];
-        this.calculator = calculator;
+        this.beatmap = beatmap;
+        this.attributes = attributes;
         this.data = data;
-        const greatWindow = new osuBase.OsuHitWindow(calculator.attributes.overallDifficulty)
-            .greatWindow * calculator.attributes.clockRate;
-        this.hitWindow = calculator.mods.some((m) => m instanceof osuBase.ModPrecise)
+        const greatWindow = new osuBase.OsuHitWindow(attributes.overallDifficulty).greatWindow *
+            attributes.clockRate;
+        this.hitWindow = attributes.mods.some((m) => m instanceof osuBase.ModPrecise)
             ? new osuBase.PreciseDroidHitWindow(osuBase.PreciseDroidHitWindow.greatWindowToOD(greatWindow))
             : new osuBase.DroidHitWindow(osuBase.DroidHitWindow.greatWindowToOD(greatWindow));
-        this.isHardRock = calculator.mods.some((m) => m instanceof osuBase.ModHardRock);
+        this.isHardRock = attributes.mods.some((m) => m instanceof osuBase.ModHardRock);
         // this.csvString = `Mods,${
         //     data.convertedMods.reduce((a, m) => a + m.acronym, "") || "NM"
         // }\nCombo,${data.maxCombo}\nAccuracy,"${(
@@ -1291,26 +1472,36 @@ class TwoHandChecker {
         //     ),
         //     this.csvString
         // );
-        let twoHandedNoteCount = 0;
-        const maxStrain = Math.max(...this.calculator.objects.map((v) => v.aimStrainWithSliders));
-        if (maxStrain) {
-            twoHandedNoteCount = this.indexedHitObjects.reduce((total, object) => {
-                if (!object.is2Handed) {
-                    return total;
-                }
-                return (total +
-                    1 /
-                        (1 +
-                            Math.exp(-((object.object.aimStrainWithSliders /
-                                maxStrain) *
-                                12 -
-                                6))));
-            }, 0);
-        }
+        // let twoHandedNoteCount = 0;
+        // const maxStrain = Math.max(
+        //     ...this.attributes.objects.map((v) => v.aimStrainWithSliders),
+        // );
+        // if (maxStrain) {
+        //     twoHandedNoteCount = this.indexedHitObjects.reduce(
+        //         (total, object) => {
+        //             if (!object.is2Handed) {
+        //                 return total;
+        //             }
+        //             return (
+        //                 total +
+        //                 1 /
+        //                     (1 +
+        //                         Math.exp(
+        //                             -(
+        //                                 (object.object.aimStrainWithSliders /
+        //                                     maxStrain) *
+        //                                     12 -
+        //                                 6
+        //                             ),
+        //                         ))
+        //             );
+        //         },
+        //         0,
+        //     );
+        // }
         return {
-            is2Hand: twoHandedNoteCount >
-                this.calculator.attributes.aimNoteCount * 0.15,
-            twoHandedNoteCount: twoHandedNoteCount,
+            is2Hand: 0 > this.attributes.aimNoteCount * 0.15,
+            twoHandedNoteCount: 0,
         };
     }
     /**
@@ -1318,8 +1509,7 @@ class TwoHandChecker {
      */
     indexHitObjects() {
         const indexes = [];
-        for (let i = 0; i <
-            Math.min(this.data.hitObjectData.length, this.calculator.objects.length); ++i) {
+        for (let i = 0; i < this.data.hitObjectData.length; ++i) {
             const indexedHitObject = this.getIndexedHitObject(i);
             indexedHitObject.sliderCheesed = this.checkSliderCheesing(indexedHitObject, this.data.hitObjectData[i]);
             indexes.push(indexedHitObject.cursorIndex);
@@ -1380,21 +1570,20 @@ class TwoHandChecker {
      * @returns The cursor index that hits the given object, -1 if the index is not found, the object is a spinner, or the object was missed.
      */
     getIndexedHitObject(objectIndex) {
-        const diffObject = this.calculator.objects[objectIndex];
-        const { object } = diffObject;
+        const object = this.beatmap.hitObjects.objects[objectIndex];
         // We don't care about the first object and spinners.
         if (objectIndex === 0 || object instanceof osuBase.Spinner) {
-            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+            return new IndexedHitObject(object, -1, -1, -1, null, false);
         }
         // We don't care if the aim strain is too low.
         // if (diffObject.aimStrainWithSliders < 200) {
         //     return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
         // }
-        const prevObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
+        const prevObject = this.beatmap.hitObjects.objects[objectIndex - 1];
         const prevObjectData = this.data.hitObjectData[objectIndex - 1];
         if (prevObject instanceof osuBase.Spinner ||
             prevObjectData.result === exports.HitResult.miss) {
-            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+            return new IndexedHitObject(object, -1, -1, -1, null, false);
         }
         const objectStartPosition = object.getStackedPosition(osuBase.Modes.droid);
         let prevObjectEndPosition = prevObject.getStackedEndPosition(osuBase.Modes.droid);
@@ -1415,7 +1604,7 @@ class TwoHandChecker {
             .subtract(prevObjectEndPosition);
         // Don't consider objects that are too close to each other.
         if (prevToCurrentMovement.length <= object.radius) {
-            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+            return new IndexedHitObject(object, -1, -1, -1, null, false);
         }
         // The case for a one-handed object is that there will be a slight movement in the cursor towards
         // the next object in fast patterns. We should not be worried about slow patterns as they will only
@@ -1435,12 +1624,12 @@ class TwoHandChecker {
         this.indexedHitObjects[objectIndex - 1].endCursorPosition =
             prevObjectInformation.position;
         if (prevObjectInformation.position.x === Number.POSITIVE_INFINITY) {
-            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+            return new IndexedHitObject(object, -1, -1, -1, null, false);
         }
         if (prevObjectInformation.cursorIndex ===
             objectInformation.cursorIndex &&
             prevObjectInformation.groupIndex === objectInformation.groupIndex) {
-            return new IndexedHitObject(diffObject, objectInformation.cursorIndex, objectInformation.groupIndex, prevObjectInformation.occurrenceIndex, 0, false);
+            return new IndexedHitObject(object, objectInformation.cursorIndex, objectInformation.groupIndex, prevObjectInformation.occurrenceIndex, 0, false);
         }
         const cursorData = this.data.cursorMovement[prevObjectInformation.cursorIndex];
         // There can be multiple angles to which the cursor moves towards the next object.
@@ -1522,9 +1711,9 @@ class TwoHandChecker {
         //     }
         // }
         if (!Number.isFinite(finalAngle)) {
-            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+            return new IndexedHitObject(object, -1, -1, -1, null, false);
         }
-        return new IndexedHitObject(diffObject, prevObjectInformation.cursorIndex, prevObjectInformation.groupIndex, prevObjectInformation.occurrenceIndex, finalAngle, is2Handed);
+        return new IndexedHitObject(object, prevObjectInformation.cursorIndex, prevObjectInformation.groupIndex, prevObjectInformation.occurrenceIndex, finalAngle, is2Handed);
     }
     /**
      * Gets the position of the cursor that presses an object.
@@ -1533,7 +1722,7 @@ class TwoHandChecker {
      * @returns The position of the cursor that presses the object.
      */
     getCursorPositionForObjectStart(objectIndex) {
-        const object = this.calculator.beatmap.hitObjects.objects[objectIndex];
+        const object = this.beatmap.hitObjects.objects[objectIndex];
         const data = this.data.hitObjectData[objectIndex];
         const objectPosition = object.getStackedPosition(osuBase.Modes.droid);
         if (object instanceof osuBase.Spinner) {
@@ -1587,7 +1776,7 @@ class TwoHandChecker {
                 if (downPosition.getDistance(objectPosition) <= object.radius &&
                     Math.abs(down.time - object.startTime) <= hitWindow) {
                     if (objectIndex > 0) {
-                        const prevObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
+                        const prevObject = this.beatmap.hitObjects.objects[objectIndex - 1];
                         if (down.time > prevObject.endTime) {
                             return {
                                 position: downPosition,
@@ -1692,11 +1881,11 @@ class TwoHandChecker {
      * @returns The position of the cursor at the object's end position.
      */
     getCursorPositionForObjectEnd(objectIndex) {
-        const object = this.calculator.beatmap.hitObjects.objects[objectIndex];
+        const object = this.beatmap.hitObjects.objects[objectIndex];
         if (!(object instanceof osuBase.Slider)) {
             return this.getCursorPositionForObjectStart(objectIndex);
         }
-        const nextObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
+        const nextObject = this.beatmap.hitObjects.objects[objectIndex - 1];
         let objectEndPosition = object.getStackedEndPosition(osuBase.Modes.droid);
         if (object.lazyTravelDistance > 0 && nextObject) {
             const nextStartPosition = nextObject.getStackedPosition(osuBase.Modes.droid);
@@ -1796,7 +1985,7 @@ class TwoHandChecker {
      * @returns Whether the slider was cheesed.
      */
     checkSliderCheesing(indexedHitObject, hitData) {
-        if (!(indexedHitObject.object.object instanceof osuBase.Slider) ||
+        if (!(indexedHitObject.object instanceof osuBase.Slider) ||
             hitData.result === exports.HitResult.miss ||
             indexedHitObject.cursorIndex === -1) {
             return false;
@@ -1812,223 +2001,30 @@ class TwoHandChecker {
 }
 
 /**
- * Utility to check whether relevant sliders in a beatmap are cheesed.
+ * Represents a replay data in an osu!droid replay version 1 and 2.
+ *
+ * Stores generic information about an osu!droid replay.
+ *
+ * This is used when analyzing replays using replay analyzer.
  */
-class SliderCheeseChecker {
-    /**
-     * @param beatmap The beatmap to analyze.
-     * @param data The data of the replay.
-     * @param difficultyAttributes The difficulty attributes of the beatmap.
-     */
-    constructor(beatmap, data, difficultyAttributes) {
-        this.beatmap = beatmap;
-        this.data = data;
-        this.difficultyAttributes = difficultyAttributes;
-        this.hitWindow50 = difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise)
-            ? new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od).mehWindow
-            : new osuBase.DroidHitWindow(beatmap.difficulty.od).mehWindow;
-        this.isHardRock = difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHardRock);
-    }
-    /**
-     * Checks if relevant sliders in the given beatmap was cheesed.
-     */
-    check() {
-        if (this.difficultyAttributes.difficultSliders.length === 0 ||
-            (this.difficultyAttributes.sliderFactor === 1 &&
-                this.difficultyAttributes.flashlightSliderFactor === 1 &&
-                this.difficultyAttributes.visualSliderFactor === 1)) {
-            return {
-                aimPenalty: 1,
-                flashlightPenalty: 1,
-                visualPenalty: 1,
-            };
-        }
-        const cheesedDifficultyRatings = this.checkSliderCheesing();
-        return this.calculateSliderCheesePenalty(cheesedDifficultyRatings);
-    }
-    /**
-     * Checks for sliders that were cheesed.
-     */
-    checkSliderCheesing() {
-        const { objects } = this.beatmap.hitObjects;
-        const cheesedDifficultyRatings = [];
-        // Current loop indices are stored for efficiency.
-        const cursorLoopIndices = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
-        const acceptableRadius = objects[0].radius * 2;
-        // Sort difficult sliders by index so that cursor loop indices work properly.
-        for (const difficultSlider of this.difficultyAttributes.difficultSliders
-            .slice()
-            .sort((a, b) => a.index - b.index)) {
-            if (difficultSlider.index >= this.data.hitObjectData.length) {
-                continue;
-            }
-            const object = objects[difficultSlider.index];
-            const objectData = this.data.hitObjectData[difficultSlider.index];
-            // If a miss or slider break occurs, we disregard the check for that slider.
-            if (objectData.result === exports.HitResult.miss ||
-                -this.hitWindow50 > objectData.accuracy ||
-                objectData.accuracy >
-                    Math.min(this.hitWindow50, object.duration)) {
-                continue;
-            }
-            const objectStartPosition = object.getStackedPosition(osuBase.Modes.droid);
-            // These time boundaries should consider the delta time between the previous and next
-            // object as well as their hit accuracy. However, they are somewhat complicated to
-            // compute and the accuracy gain is small. As such, let's settle with 50 hit window.
-            const minTimeLimit = object.startTime - this.hitWindow50;
-            const maxTimeLimit = object.startTime + this.hitWindow50;
-            // Get the closest tap distance across all cursors.
-            const closestDistances = [];
-            const closestGroupIndices = [];
-            for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-                const cursorGroups = this.data.cursorMovement[i].occurrenceGroups;
-                let closestDistance = Number.POSITIVE_INFINITY;
-                let closestIndex = cursorGroups.length;
-                for (let j = cursorLoopIndices[i]; j < cursorGroups.length; j = ++cursorLoopIndices[i]) {
-                    const group = cursorGroups[j];
-                    if (group.endTime < minTimeLimit) {
-                        continue;
-                    }
-                    if (group.startTime > maxTimeLimit) {
-                        break;
-                    }
-                    if (group.startTime >= minTimeLimit) {
-                        const position = this.getCursorPosition(group.down);
-                        const distance = position.getDistance(objectStartPosition);
-                        if (closestDistance > distance) {
-                            closestDistance = distance;
-                            closestIndex = j;
-                        }
-                        if (closestDistance <= acceptableRadius / 2) {
-                            break;
-                        }
-                    }
-                    // Normally, we check if there are cursor presses within the group's active time.
-                    // However, some funky workarounds are used throughout the game for replays, so
-                    // for the time being we only check for cursor distances across the group.
-                    const { allOccurrences } = group;
-                    for (let k = 1; k < allOccurrences.length; ++k) {
-                        const cursor = allOccurrences[k];
-                        const prevCursor = allOccurrences[k - 1];
-                        let distance = Number.POSITIVE_INFINITY;
-                        const currentPosition = this.getCursorPosition(cursor);
-                        const prevPosition = this.getCursorPosition(prevCursor);
-                        switch (cursor.id) {
-                            case exports.MovementType.up:
-                                distance =
-                                    prevPosition.getDistance(objectStartPosition);
-                                break;
-                            case exports.MovementType.move:
-                                for (let mSecPassed = Math.max(prevCursor.time, minTimeLimit); mSecPassed <=
-                                    Math.min(cursor.time, maxTimeLimit); ++mSecPassed) {
-                                    const t = (mSecPassed - prevCursor.time) /
-                                        (cursor.time - prevCursor.time);
-                                    const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
-                                    distance =
-                                        cursorPosition.getDistance(objectStartPosition);
-                                    if (closestDistance > distance) {
-                                        closestDistance = distance;
-                                        closestIndex = j;
-                                    }
-                                    if (closestDistance <=
-                                        acceptableRadius / 2) {
-                                        break;
-                                    }
-                                }
-                        }
-                        if (closestDistance > distance) {
-                            closestDistance = distance;
-                            closestIndex = j;
-                        }
-                        if (closestDistance <= acceptableRadius / 2) {
-                            break;
-                        }
-                    }
-                }
-                closestDistances.push(closestDistance);
-                closestGroupIndices.push(closestIndex);
-                if (cursorLoopIndices[i] > 0) {
-                    // Decrement the index. The previous group may also have a role on the next slider.
-                    --cursorLoopIndices[i];
-                }
-            }
-            const cursorIndex = closestDistances.indexOf(Math.min(...closestDistances));
-            const closestDistance = closestDistances[cursorIndex];
-            if (closestDistance > acceptableRadius / 2) {
-                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
-                continue;
-            }
-            const group = this.data.cursorMovement[cursorIndex].occurrenceGroups[closestGroupIndices[cursorIndex]];
-            let isCheesed = false;
-            // Track cursor movement to see if it lands on every tick.
-            let occurrenceLoopIndex = 1;
-            const { allOccurrences } = group;
-            for (let i = 1; i < object.nestedHitObjects.length; ++i) {
-                if (isCheesed) {
-                    break;
-                }
-                const tickWasHit = objectData.tickset[i - 1];
-                if (!tickWasHit) {
-                    continue;
-                }
-                const nestedObject = object.nestedHitObjects[i];
-                const nestedPosition = nestedObject.getStackedPosition(osuBase.Modes.droid);
-                while (occurrenceLoopIndex < allOccurrences.length &&
-                    allOccurrences[occurrenceLoopIndex].time <
-                        nestedObject.startTime) {
-                    ++occurrenceLoopIndex;
-                }
-                if (occurrenceLoopIndex === allOccurrences.length) {
-                    continue;
-                }
-                const cursor = allOccurrences[occurrenceLoopIndex];
-                const prevCursor = allOccurrences[occurrenceLoopIndex - 1];
-                const currentPosition = this.getCursorPosition(cursor);
-                const prevPosition = this.getCursorPosition(prevCursor);
-                switch (cursor.id) {
-                    case exports.MovementType.move: {
-                        // Interpolate cursor position during nested object time.
-                        const t = (nestedObject.startTime - prevCursor.time) /
-                            (cursor.time - prevCursor.time);
-                        const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
-                        const distance = cursorPosition.getDistance(nestedPosition);
-                        isCheesed = distance > acceptableRadius;
-                        break;
-                    }
-                    case exports.MovementType.up:
-                        isCheesed =
-                            prevPosition.getDistance(nestedPosition) >
-                                acceptableRadius;
-                }
-            }
-            if (isCheesed) {
-                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
-            }
-        }
-        return cheesedDifficultyRatings;
+class ReplayData {
+    constructor(values) {
+        this.replayVersion = values.replayVersion;
+        this.folderName = values.folderName;
+        this.fileName = values.fileName;
+        this.hash = values.hash;
+        this.accuracy = values.accuracy;
+        this.rank = values.rank;
+        this.hit300k = values.hit300k;
+        this.hit100k = values.hit100k;
+        this.cursorMovement = values.cursorMovement;
+        this.hitObjectData = values.hitObjectData;
     }
     /**
-     * Calculates the slider cheese penalty.
+     * Whether the replay's version is 3 or later.
      */
-    calculateSliderCheesePenalty(cheesedDifficultyRatings) {
-        const summedDifficultyRating = Math.min(1, cheesedDifficultyRatings.reduce((a, v) => a + v, 0));
-        return {
-            aimPenalty: Math.max(this.difficultyAttributes.sliderFactor, Math.pow(1 -
-                summedDifficultyRating *
-                    this.difficultyAttributes.sliderFactor, 2)),
-            flashlightPenalty: Math.max(this.difficultyAttributes.flashlightSliderFactor, Math.pow(1 -
-                summedDifficultyRating *
-                    this.difficultyAttributes.flashlightSliderFactor, 2)),
-            visualPenalty: Math.max(this.difficultyAttributes.visualSliderFactor, Math.pow(1 -
-                summedDifficultyRating *
-                    this.difficultyAttributes.visualSliderFactor, 2)),
-        };
-    }
-    getCursorPosition(cursor) {
-        if (this.isHardRock) {
-            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
-        }
-        return cursor.position;
+    isReplayV3() {
+        return this.replayVersion >= 3;
     }
 }
 
@@ -2040,20 +2036,6 @@ class SliderCheeseChecker {
  * This is used when analyzing replays using replay analyzer.
  */
 class ReplayV3Data extends ReplayData {
-    /**
-     * The complete mod string of this replay (mods, speed multiplier, and forced difficulty statistics combined).
-     */
-    get completeModString() {
-        return this.modString;
-    }
-    /**
-     * The mod string of this replay (mods only).
-     */
-    get modString() {
-        return this.convertedMods.length > 0
-            ? this.convertedMods.map((v) => v.acronym).join("")
-            : "No Mod";
-    }
     constructor(values) {
         super(values);
         this.time = values.time;
@@ -2061,87 +2043,10 @@ class ReplayV3Data extends ReplayData {
         this.maxCombo = values.maxCombo;
         this.isFullCombo = values.isFullCombo;
         this.playerName = values.playerName;
-        this.rawMods = values.rawMods;
         this.convertedMods = values.convertedMods;
     }
 }
 
-/**
- * Represents a replay data for replay version 4.
- *
- * Stores generic information about an osu!droid replay.
- *
- * This is used when analyzing replays using replay analyzer.
- */
-class ReplayV4Data extends ReplayV3Data {
-    get completeModString() {
-        let finalString = this.modString;
-        const customStats = [];
-        if (this.speedMultiplier !== 1) {
-            customStats.push(`${this.speedMultiplier}x`);
-        }
-        if (this.forceAR !== undefined) {
-            customStats.push(`AR${this.forceAR}`);
-        }
-        if (this.flashlightFollowDelay !== undefined) {
-            customStats.push(`FLD${this.flashlightFollowDelay}`);
-        }
-        if (customStats.length > 0) {
-            finalString += ` (${customStats.join(", ")})`;
-        }
-        return finalString;
-    }
-    constructor(values) {
-        var _a, _b;
-        super(values);
-        this.forceAR = values.forceAR;
-        this.speedMultiplier = (_a = values.speedMultiplier) !== null && _a !== void 0 ? _a : 1;
-        this.flashlightFollowDelay = (_b = values.flashlightFollowDelay) !== null && _b !== void 0 ? _b : 0.12;
-    }
-}
-
-/**
- * Represents a replay data for replay version 5.
- *
- * Stores generic information about an osu!droid replay.
- *
- * This is used when analyzing replays using replay analyzer.
- */
-class ReplayV5Data extends ReplayV4Data {
-    get completeModString() {
-        let finalString = this.modString;
-        const customStats = [];
-        if (this.speedMultiplier !== 1) {
-            customStats.push(`${this.speedMultiplier}x`);
-        }
-        if (this.forceAR !== undefined) {
-            customStats.push(`AR${this.forceAR}`);
-        }
-        if (this.forceOD !== undefined) {
-            customStats.push(`OD${this.forceOD}`);
-        }
-        if (this.forceCS !== undefined) {
-            customStats.push(`CS${this.forceCS}`);
-        }
-        if (this.forceHP !== undefined) {
-            customStats.push(`HP${this.forceHP}`);
-        }
-        if (this.flashlightFollowDelay !== undefined) {
-            customStats.push(`FLD${this.flashlightFollowDelay}`);
-        }
-        if (customStats.length > 0) {
-            finalString += ` (${customStats.join(", ")})`;
-        }
-        return finalString;
-    }
-    constructor(values) {
-        super(values);
-        this.forceCS = values.forceCS;
-        this.forceOD = values.forceOD;
-        this.forceHP = values.forceHP;
-    }
-}
-
 /**
  * A replay analyzer that analyzes a replay from osu!droid.
  *
@@ -2196,11 +2101,11 @@ class ReplayAnalyzer {
          */
         this.twoHandedNoteCount = 0;
         this.bufferOffset = 0;
-        this.scoreID = values.scoreID;
-        this.beatmap = values.map;
-        this.difficultyAttributes = values.difficultyAttributes;
-        if (this.beatmap && !(this.beatmap instanceof osuBase.Beatmap)) {
-            this.difficultyAttributes = this.beatmap.attributes;
+        this.scoreID = values === null || values === void 0 ? void 0 : values.scoreID;
+        this.beatmap = values === null || values === void 0 ? void 0 : values.map;
+        this.difficultyAttributes = values === null || values === void 0 ? void 0 : values.difficultyAttributes;
+        if (this.beatmap instanceof osuBase.DroidPlayableBeatmap) {
+            this.playableBeatmap = this.beatmap;
         }
     }
     /**
@@ -2239,16 +2144,12 @@ class ReplayAnalyzer {
         let negativeCount = 0;
         let positiveTotal = 0;
         let negativeTotal = 0;
-        const beatmap = this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
-            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
-            ? this.beatmap.beatmap
-            : this.beatmap;
-        const { objects } = beatmap.hitObjects;
+        const { objects } = this.beatmap.hitObjects;
         const mods = this.data.isReplayV3()
             ? this.data.convertedMods
             : (_b = (_a = this.difficultyAttributes) === null || _a === void 0 ? void 0 : _a.mods.filter((m) => m.isApplicableToDroid())) !== null && _b !== void 0 ? _b : [];
-        const adjustedDifficulty = new osuBase.BeatmapDifficulty(beatmap.difficulty);
-        osuBase.ModUtil.applyModsToBeatmapDifficulty(adjustedDifficulty, osuBase.Modes.droid, mods, this.data.isReplayV4() ? this.data.speedMultiplier : 1);
+        const adjustedDifficulty = new osuBase.BeatmapDifficulty(this.beatmap.difficulty);
+        osuBase.ModUtil.applyModsToBeatmapDifficulty(adjustedDifficulty, osuBase.Modes.droid, mods);
         const mehWindow = mods.some((m) => m instanceof osuBase.ModPrecise)
             ? new osuBase.PreciseDroidHitWindow(adjustedDifficulty.od).mehWindow
             : new osuBase.DroidHitWindow(adjustedDifficulty.od).mehWindow;
@@ -2304,15 +2205,15 @@ class ReplayAnalyzer {
     /**
      * Checks if a play is using 2 hands.
      *
-     * Requires `analyze()` to be called first and `map` to be defined as `DroidDifficultyCalculator`.
+     * Requires `analyze()` to be called first as well as `beatmap` and `difficultyAttributes` to be defined.
      */
     checkFor2Hand() {
-        if (!(this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
-            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator) ||
-            !this.data) {
+        var _a;
+        if (!this.beatmap || !this.difficultyAttributes || !this.data) {
             return;
         }
-        const twoHandChecker = new TwoHandChecker(this.beatmap, this.data);
+        (_a = this.playableBeatmap) !== null && _a !== void 0 ? _a : (this.playableBeatmap = this.constructPlayableBeatmap());
+        const twoHandChecker = new TwoHandChecker(this.playableBeatmap, this.difficultyAttributes, this.data);
         const result = twoHandChecker.check();
         this.is2Hand = result.is2Hand;
         this.twoHandedNoteCount = result.twoHandedNoteCount;
@@ -2338,6 +2239,9 @@ class ReplayAnalyzer {
      */
     downloadReplay() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.scoreID === undefined) {
+                return null;
+            }
             const apiRequestBuilder = new osuBase.DroidAPIRequestBuilder()
                 .setRequireAPIkey(false)
                 .setEndpoint("upload")
@@ -2407,7 +2311,6 @@ class ReplayAnalyzer {
             isFullCombo: false,
             maxCombo: 0,
             playerName: "",
-            rawMods: [],
             score: 0,
             time: new Date(0),
         };
@@ -2423,53 +2326,34 @@ class ReplayAnalyzer {
             resultObject.maxCombo = rawObject[4].readInt32BE(36);
             resultObject.isFullCombo = resultObject.accuracy.value() === 1;
             resultObject.playerName = rawObject[5];
-            resultObject.rawMods = Object.values(rawObject[6].elements);
-            resultObject.convertedMods = osuBase.ModUtil.droidStringToMods(this.convertDroidMods(resultObject.rawMods));
-            resultObject.rank = this.calculateRank(resultObject);
-        }
-        if (resultObject.replayVersion >= 4) {
-            const str = rawObject[7].split("|");
-            for (const s of str) {
-                switch (true) {
-                    // Forced stats
-                    case s.startsWith("CS"):
-                        resultObject.forceCS = parseFloat(s.replace("CS", ""));
-                        break;
-                    case s.startsWith("AR"):
-                        resultObject.forceAR = parseFloat(s.replace("AR", ""));
-                        break;
-                    case s.startsWith("OD"):
-                        resultObject.forceOD = parseFloat(s.replace("OD", ""));
-                        break;
-                    case s.startsWith("HP"):
-                        resultObject.forceHP = parseFloat(s.replace("HP", ""));
-                        break;
-                    // FL follow delay
-                    case s.startsWith("FLD"):
-                        resultObject.flashlightFollowDelay =
-                            parseFloat(s.replace("FLD", "")) || 0.12;
-                        break;
-                    // Speed multiplier
-                    case s.startsWith("x"):
-                        resultObject.speedMultiplier =
-                            parseFloat(s.replace("x", "")) || 1;
-                        break;
+            if (resultObject.replayVersion >= 7) {
+                resultObject.convertedMods = osuBase.ModUtil.deserializeMods(rawObject[6]);
+            }
+            else {
+                resultObject.convertedMods = this.convertDroidMods(resultObject.replayVersion, Object.values(rawObject[6].elements));
+                if (resultObject.replayVersion >= 4) {
+                    osuBase.DroidLegacyModConverter.parseExtraModString(resultObject.convertedMods, rawObject[7].split("|"));
                 }
             }
+            resultObject.rank = this.calculateRank(resultObject);
         }
         let bufferIndex;
-        switch (true) {
-            // replay v4 and above
-            case resultObject.replayVersion >= 4:
-                bufferIndex = 8;
+        switch (resultObject.replayVersion) {
+            case 1:
+            case 2:
+                bufferIndex = 4;
                 break;
-            // replay v3
-            case resultObject.replayVersion === 3:
+            case 3:
+            case 7:
                 bufferIndex = 7;
                 break;
-            // replay v1 and v2
+            case 4:
+            case 5:
+            case 6:
+                bufferIndex = 8;
+                break;
             default:
-                bufferIndex = 4;
+                throw new Error("Unsupported replay version: " + resultObject.replayVersion);
         }
         const replayDataBufferArray = [];
         while (bufferIndex < rawObject.length) {
@@ -2483,14 +2367,10 @@ class ReplayAnalyzer {
         this.parseOldReplayInformation(resultObject);
         switch (resultObject.replayVersion) {
             case 3:
-                this.data = new ReplayV3Data(resultObject);
-                break;
             case 4:
-                this.data = new ReplayV4Data(resultObject);
-                break;
             case 5:
             case 6:
-                this.data = new ReplayV5Data(resultObject);
+                this.data = new ReplayV3Data(resultObject);
                 break;
             default:
                 this.data = new ReplayData(resultObject);
@@ -2499,38 +2379,44 @@ class ReplayAnalyzer {
     /**
      * Converts replay mods to droid mod string.
      */
-    convertDroidMods(replayMods) {
+    convertDroidMods(replayVersion, replayMods) {
         const replayModsConstants = {
-            MOD_AUTO: new osuBase.ModAuto().droidString,
-            MOD_AUTOPILOT: new osuBase.ModAutopilot().droidString,
-            MOD_NOFAIL: new osuBase.ModNoFail().droidString,
-            MOD_EASY: new osuBase.ModEasy().droidString,
-            MOD_HIDDEN: new osuBase.ModHidden().droidString,
-            MOD_HARDROCK: new osuBase.ModHardRock().droidString,
-            MOD_DOUBLETIME: new osuBase.ModDoubleTime().droidString,
-            MOD_HALFTIME: new osuBase.ModHalfTime().droidString,
-            MOD_NIGHTCORE: new osuBase.ModNightCore().droidString,
-            MOD_PRECISE: new osuBase.ModPrecise().droidString,
-            MOD_SMALLCIRCLE: new osuBase.ModSmallCircle().droidString,
-            MOD_REALLYEASY: new osuBase.ModReallyEasy().droidString,
-            MOD_RELAX: new osuBase.ModRelax().droidString,
-            MOD_PERFECT: new osuBase.ModPerfect().droidString,
-            MOD_SUDDENDEATH: new osuBase.ModSuddenDeath().droidString,
-            MOD_SCOREV2: new osuBase.ModScoreV2().droidString,
-            MOD_FLASHLIGHT: new osuBase.ModFlashlight().droidString,
+            MOD_AUTO: new osuBase.ModAuto(),
+            MOD_AUTOPILOT: new osuBase.ModAutopilot(),
+            MOD_NOFAIL: new osuBase.ModNoFail(),
+            MOD_EASY: new osuBase.ModEasy(),
+            MOD_HIDDEN: new osuBase.ModHidden(),
+            MOD_TRACEABLE: new osuBase.ModTraceable(),
+            MOD_HARDROCK: new osuBase.ModHardRock(),
+            MOD_DOUBLETIME: new osuBase.ModDoubleTime(),
+            MOD_HALFTIME: new osuBase.ModHalfTime(),
+            MOD_NIGHTCORE: new osuBase.ModNightCore(),
+            MOD_PRECISE: new osuBase.ModPrecise(),
+            MOD_SMALLCIRCLE: new osuBase.ModSmallCircle(),
+            MOD_REALLYEASY: new osuBase.ModReallyEasy(),
+            MOD_RELAX: new osuBase.ModRelax(),
+            MOD_PERFECT: new osuBase.ModPerfect(),
+            MOD_SUDDENDEATH: new osuBase.ModSuddenDeath(),
+            MOD_SCOREV2: new osuBase.ModScoreV2(),
+            MOD_FLASHLIGHT: new osuBase.ModFlashlight(),
         };
-        let modString = "";
+        const mods = [];
         for (const mod of replayMods) {
             for (const property in replayModsConstants) {
                 if (!mod.includes(property)) {
                     continue;
                 }
-                modString +=
-                    replayModsConstants[property];
+                if (replayVersion <= 3 && mod === "MOD_NIGHTCORE") {
+                    // In replay v3, the NightCore mod is bugged. See ModOldNightCore's description.
+                    mods.push(new osuBase.ModOldNightCore());
+                }
+                else {
+                    mods.push(replayModsConstants[property]);
+                }
                 break;
             }
         }
-        return modString;
+        return mods;
     }
     parseMovementData(resultObject, replayDataBuffer) {
         resultObject.cursorMovement.length = 0;
@@ -2605,10 +2491,7 @@ class ReplayAnalyzer {
         if (resultObject.replayVersion >= 3) {
             return;
         }
-        const objects = (_a = (this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
-            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
-            ? this.beatmap.beatmap
-            : this.beatmap)) === null || _a === void 0 ? void 0 : _a.hitObjects.objects;
+        const objects = (_a = this.beatmap) === null || _a === void 0 ? void 0 : _a.hitObjects.objects;
         let grantsGekiOrKatu = true;
         for (let i = 0; i < resultObject.hitObjectData.length; ++i) {
             // Hit result
@@ -2677,35 +2560,16 @@ class ReplayAnalyzer {
     }
     constructPlayableBeatmap() {
         var _a, _b;
+        if (this.beatmap instanceof osuBase.DroidPlayableBeatmap) {
+            return this.beatmap;
+        }
         if (!this.beatmap || !this.data) {
             throw new Error("Beatmap and replay data must be defined.");
         }
         const mods = this.data.isReplayV3()
-            ? this.data.convertedMods.slice()
-            : (_b = (_a = this.difficultyAttributes) === null || _a === void 0 ? void 0 : _a.mods.slice()) !== null && _b !== void 0 ? _b : [];
-        if (this.data.isReplayV5() &&
-            [
-                this.data.forceCS,
-                this.data.forceAR,
-                this.data.forceOD,
-                this.data.forceHP,
-            ].some((v) => v !== undefined)) {
-            mods.push(new osuBase.ModDifficultyAdjust({
-                cs: this.data.forceCS,
-                ar: this.data.forceAR,
-                od: this.data.forceOD,
-                hp: this.data.forceHP,
-            }));
-        }
-        return (this.beatmap instanceof osuBase.Beatmap
-            ? this.beatmap
-            : this.beatmap.beatmap).createPlayableBeatmap({
-            mode: osuBase.Modes.droid,
-            mods: mods,
-            customSpeedMultiplier: this.data.isReplayV4()
-                ? this.data.speedMultiplier
-                : 1,
-        });
+            ? this.data.convertedMods
+            : (_b = (_a = this.difficultyAttributes) === null || _a === void 0 ? void 0 : _a.mods) !== null && _b !== void 0 ? _b : [];
+        return this.beatmap.createDroidPlayableBeatmap(mods);
     }
     readByte(buffer) {
         const num = buffer.readInt8(this.bufferOffset);
@@ -2752,8 +2616,6 @@ exports.ReplayAnalyzer = ReplayAnalyzer;
 exports.ReplayData = ReplayData;
 exports.ReplayObjectData = ReplayObjectData;
 exports.ReplayV3Data = ReplayV3Data;
-exports.ReplayV4Data = ReplayV4Data;
-exports.ReplayV5Data = ReplayV5Data;
 exports.SliderCheeseChecker = SliderCheeseChecker;
 exports.ThreeFingerChecker = ThreeFingerChecker;
 exports.TwoHandChecker = TwoHandChecker;