@rian8337/osu-droid-replay-analyzer 4.0.0-beta.15 → 4.0.0-beta.17

package/dist/index.js

@@ -312,6 +312,574 @@ exports.HitResult = void 0;
     HitResult[HitResult["great"] = 4] = "great";
 })(exports.HitResult || (exports.HitResult = {}));
 
+/**
+ * Utility to check whether or not a beatmap is three-fingered for rebalance scores.
+ */
+class RebalanceThreeFingerChecker {
+    /**
+     * The beatmap that is being analyzed.
+     */
+    beatmap;
+    /**
+     * The data of the replay.
+     */
+    data;
+    /**
+     * The difficulty attributes of the beatmap.
+     */
+    difficultyAttributes;
+    /**
+     * The hitobjects to be analyzed.
+     *
+     * This is being maintained separately due to possible change in object scale.
+     */
+    hitObjects;
+    /**
+     * The distance threshold between cursors to assume that two cursors are
+     * actually pressed with 1 finger in osu!pixels.
+     *
+     * This is used to prevent cases where a player would lift their finger
+     * too fast to the point where the 4th cursor instance or beyond is recorded
+     * as 1st, 2nd, or 3rd cursor instance.
+     */
+    cursorDistancingDistanceThreshold = 60;
+    /**
+     * The threshold for the amount of cursors that are assumed to be pressed
+     * by a single finger.
+     */
+    cursorDistancingCountThreshold = 10;
+    /**
+     * The threshold for the time difference of cursors that are assumed to be pressed
+     * by a single finger, in milliseconds.
+     */
+    cursorDistancingTimeThreshold = 1000;
+    /**
+     * The amount of notes that has a tap strain exceeding `strainThreshold`.
+     */
+    strainNoteCount;
+    /**
+     * The ratio threshold between non-3 finger cursors and 3-finger cursors.
+     *
+     * Increasing this number will increase detection accuracy, however
+     * it also increases the chance of falsely flagged plays.
+     */
+    threeFingerRatioThreshold = 0.01;
+    /**
+     * Extended sections of the beatmap for drag detection.
+     */
+    beatmapSections = [];
+    /**
+     * The hit window of this beatmap. Keep in mind that speed-changing mods do not change hit window length in game logic.
+     */
+    hitWindow;
+    /**
+     * A reprocessed break points to match right on object time.
+     *
+     * This is used to increase detection accuracy since break points do not start right at the
+     * start of the hitobject before it and do not end right at the first hitobject after it.
+     */
+    breakPointAccurateTimes = [];
+    /**
+     * A cursor occurrence nested array that only contains `movementType.DOWN` movement ID occurrences.
+     *
+     * Each index represents the cursor index.
+     */
+    downCursorInstances = [];
+    /**
+     * Nerf factors from all sections that were three-fingered.
+     */
+    nerfFactors = [];
+    /**
+     * Whether this score uses the Precise mod.
+     */
+    isPrecise;
+    /**
+     * @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;
+        const od = osuBase.calculateDroidDifficultyStatistics({
+            overallDifficulty: beatmap.difficulty.od,
+            mods: this.difficultyAttributes.mods.filter((m) => m.isApplicableToDroid() &&
+                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
+            convertOverallDifficulty: false,
+        }).overallDifficulty;
+        this.isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
+        this.hitWindow = new osuBase.DroidHitWindow(od);
+        this.strainNoteCount =
+            this.difficultyAttributes.possibleThreeFingeredSections.reduce((a, v) => a + v.lastObjectIndex - v.firstObjectIndex + 1, 0);
+        this.hitObjects = beatmap.hitObjects.objects;
+    }
+    /**
+     * Checks whether a beatmap is eligible to be detected for 3-finger.
+     *
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
+     */
+    static isEligibleToDetect(difficultyAttributes) {
+        return difficultyAttributes.possibleThreeFingeredSections.length > 0;
+    }
+    /**
+     * Checks if the given beatmap is 3-fingered and also returns the final penalty.
+     *
+     * The beatmap will be separated into sections and each section will be determined
+     * whether or not it is dragged.
+     *
+     * After that, each section will be assigned a nerf factor based on whether or not
+     * the section is 3-fingered. These nerf factors will be summed up into a final
+     * nerf factor, taking beatmap difficulty into account.
+     */
+    check() {
+        if (this.strainNoteCount === 0) {
+            return { is3Finger: false, penalty: 1 };
+        }
+        this.getAccurateBreakPoints();
+        this.filterCursorInstances();
+        this.getBeatmapSections();
+        this.calculateNerfFactors();
+        const finalPenalty = this.calculateFinalPenalty();
+        return { is3Finger: finalPenalty > 1, penalty: finalPenalty };
+    }
+    /**
+     * Generates a new set of "accurate break points".
+     *
+     * This is done to increase detection accuracy since break points do not start right at the
+     * end of the hitobject before it and do not end right at the first hitobject after it.
+     */
+    getAccurateBreakPoints() {
+        const objectData = this.data.hitObjectData;
+        for (const breakPoint of this.beatmap.events.breaks) {
+            const beforeIndex = osuBase.MathUtils.clamp(this.hitObjects.findIndex((o) => o.endTime >= breakPoint.startTime) - 1, 0, this.hitObjects.length - 2);
+            const objectBefore = this.hitObjects[beforeIndex];
+            const objectBeforeData = objectData[beforeIndex];
+            let timeBefore = objectBefore.endTime;
+            if (objectBefore instanceof osuBase.Circle) {
+                if (objectBeforeData.result !== exports.HitResult.miss) {
+                    timeBefore += objectBeforeData.accuracy;
+                }
+                else {
+                    timeBefore += this.hitWindow.hitWindowFor50(this.isPrecise);
+                }
+            }
+            const afterIndex = beforeIndex + 1;
+            const objectAfter = this.hitObjects[afterIndex];
+            const objectAfterData = objectData[afterIndex];
+            let timeAfter = this.hitObjects[afterIndex].startTime;
+            if (objectAfter instanceof osuBase.Circle &&
+                objectAfterData.result !== exports.HitResult.miss) {
+                timeAfter += objectAfterData.accuracy;
+            }
+            this.breakPointAccurateTimes.push(new osuBase.BreakPoint({
+                startTime: timeBefore,
+                endTime: timeAfter,
+            }));
+        }
+    }
+    /**
+     * Filters the original cursor instances, returning only those with `movementType.DOWN` movement ID.
+     *
+     * This also filters cursors that are in break period or happen before start/after end of the beatmap.
+     */
+    filterCursorInstances() {
+        const objectData = this.data.hitObjectData;
+        const firstObjectResult = objectData[0].result;
+        const lastObjectResult = objectData.at(-1).result;
+        const firstObject = this.hitObjects[0];
+        const lastObject = this.hitObjects.at(-1);
+        // For sliders, automatically set hit window length to be as lenient as possible.
+        let firstObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
+        if (firstObject instanceof osuBase.Circle) {
+            switch (firstObjectResult) {
+                case exports.HitResult.great:
+                    firstObjectHitWindow = this.hitWindow.hitWindowFor300(this.isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    firstObjectHitWindow = this.hitWindow.hitWindowFor100(this.isPrecise);
+                    break;
+                default:
+                    firstObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
+            }
+        }
+        // For sliders, automatically set hit window length to be as lenient as possible.
+        let lastObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
+        if (lastObject instanceof osuBase.Circle) {
+            switch (lastObjectResult) {
+                case exports.HitResult.great:
+                    lastObjectHitWindow = this.hitWindow.hitWindowFor300(this.isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    lastObjectHitWindow = this.hitWindow.hitWindowFor100(this.isPrecise);
+                    break;
+                default:
+                    lastObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
+            }
+        }
+        else if (lastObject instanceof osuBase.Slider) {
+            lastObjectHitWindow = Math.min(lastObject.spanDuration, lastObjectHitWindow);
+        }
+        // These hit time uses hit window length as threshold.
+        // This is because cursors aren't recorded exactly at hit time,
+        // probably due to the game's behavior.
+        const firstObjectHitTime = firstObject.startTime - firstObjectHitWindow;
+        const lastObjectHitTime = lastObject.startTime + lastObjectHitWindow;
+        for (const cursorInstance of this.data.cursorMovement) {
+            const validOccurrences = [];
+            for (const group of cursorInstance.occurrenceGroups) {
+                if (group.startTime < firstObjectHitTime) {
+                    continue;
+                }
+                if (group.startTime > lastObjectHitTime) {
+                    break;
+                }
+                if (this.breakPointAccurateTimes.some((v) => group.startTime >= v.startTime &&
+                    group.endTime <= v.endTime)) {
+                    continue;
+                }
+                validOccurrences.push(group.down);
+            }
+            this.downCursorInstances.push(validOccurrences);
+        }
+    }
+    /**
+     * Divides the beatmap into sections, which will be used to
+     * detect dragged sections and improve detection speed.
+     */
+    getBeatmapSections() {
+        const cursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+        for (const section of this.difficultyAttributes
+            .possibleThreeFingeredSections) {
+            const dragFingerIndex = this.findDragIndex(section);
+            const objects = [];
+            for (let i = section.firstObjectIndex; i <= section.lastObjectIndex; ++i) {
+                objects.push({
+                    object: this.hitObjects[i],
+                    ...this.getObjectPressIndex(this.hitObjects[i], this.data.hitObjectData[i], cursorLookupIndices, dragFingerIndex),
+                });
+            }
+            this.beatmapSections.push({
+                ...section,
+                dragFingerIndex: dragFingerIndex,
+                objects: objects,
+            });
+        }
+    }
+    /**
+     * Obtains the index of the nearest cursor of which an object was pressed in terms of time.
+     *
+     * @param object The object to obtain the index for.
+     * @param objectData The hit data of the object.
+     * @param cursorLookupIndices The cursor indices to start looking for the cursor from, to save computation time.
+     * @param excludedIndices The cursor indices that should not be checked.
+     * @returns The index of the cursor, -1 if the object was missed or it's a spinner.
+     */
+    getObjectPressIndex(object, objectData, cursorLookupIndices, ...excludedCursorIndices) {
+        if (objectData.result === exports.HitResult.miss || object instanceof osuBase.Spinner) {
+            return {
+                pressingCursorInstanceIndex: -1,
+                pressingCursorIndex: -1,
+            };
+        }
+        const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
+        // Check for sliderbreaks and treat them as misses.
+        if (object instanceof osuBase.Slider &&
+            objectData.accuracy === Math.floor(hitWindow50) + 13) {
+            return {
+                pressingCursorInstanceIndex: -1,
+                pressingCursorIndex: -1,
+            };
+        }
+        // We are not directly using hit time to determine which cursor pressed the object
+        // to account for time difference between hit registration and object judgement.
+        let minHitTime = object.startTime;
+        let maxHitTime = object.startTime;
+        if (object instanceof osuBase.Circle) {
+            let hitWindowGap = hitWindow50;
+            switch (objectData.result) {
+                case exports.HitResult.great:
+                    hitWindowGap = this.hitWindow.hitWindowFor300(this.isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    hitWindowGap = this.hitWindow.hitWindowFor100(this.isPrecise);
+                    break;
+            }
+            minHitTime -= hitWindowGap;
+            maxHitTime += hitWindowGap;
+        }
+        else if (object instanceof osuBase.Slider) {
+            minHitTime -= hitWindow50;
+            maxHitTime += Math.min(hitWindow50, object.spanDuration);
+        }
+        const hitTime = object.startTime + objectData.accuracy;
+        let nearestCursorInstanceIndex = null;
+        let nearestCursorIndex = null;
+        let nearestTime = Number.POSITIVE_INFINITY;
+        for (let i = 0; i < this.downCursorInstances.length; ++i) {
+            if (excludedCursorIndices.includes(i)) {
+                continue;
+            }
+            const cursors = this.downCursorInstances[i];
+            for (let j = cursorLookupIndices[i]; j < cursors.length; cursorLookupIndices[i] = ++j) {
+                const cursor = cursors[j];
+                if (cursor.time < minHitTime) {
+                    continue;
+                }
+                if (cursor.time > maxHitTime) {
+                    break;
+                }
+                const deltaTime = Math.abs(hitTime - cursor.time);
+                if (deltaTime > nearestTime) {
+                    break;
+                }
+                nearestCursorInstanceIndex = i;
+                nearestCursorIndex = j;
+                nearestTime = deltaTime;
+            }
+        }
+        return {
+            pressingCursorInstanceIndex: nearestCursorInstanceIndex ?? -1,
+            pressingCursorIndex: nearestCursorIndex ?? -1,
+        };
+    }
+    /**
+     * Checks if a section is dragged and returns the index of the drag finger.
+     *
+     * If the section is not dragged, -1 will be returned.
+     *
+     * @param section The section to check.
+     */
+    findDragIndex(section) {
+        const objectData = this.data.hitObjectData;
+        const firstObject = this.hitObjects[section.firstObjectIndex];
+        const lastObject = this.hitObjects[section.lastObjectIndex];
+        let firstObjectMinHitTime = firstObject.startTime;
+        if (firstObject instanceof osuBase.Circle) {
+            switch (objectData[section.firstObjectIndex].result) {
+                case exports.HitResult.great:
+                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor300(this.isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor100(this.isPrecise);
+                    break;
+                default:
+                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
+            }
+        }
+        else if (firstObject instanceof osuBase.Slider) {
+            firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
+        }
+        let lastObjectMaxHitTime = lastObject.startTime;
+        if (lastObject instanceof osuBase.Circle) {
+            switch (objectData[section.lastObjectIndex].result) {
+                case exports.HitResult.great:
+                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor300(this.isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor100(this.isPrecise);
+                    break;
+                default:
+                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(this.isPrecise);
+            }
+        }
+        else if (lastObject instanceof osuBase.Slider) {
+            lastObjectMaxHitTime += Math.min(this.hitWindow.hitWindowFor50(this.isPrecise), lastObject.spanDuration);
+        }
+        // Since there may be more than 1 cursor instance index,
+        // we check which cursor instance follows hitobjects all over.
+        const cursorIndices = [];
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const c = this.data.cursorMovement[i];
+            if (c.occurrenceGroups.length === 0) {
+                continue;
+            }
+            // Do not include cursors that don't have an occurence in this section
+            // this speeds up checking process.
+            if (c.occurrenceGroups.filter((v) => v.startTime >= firstObjectMinHitTime &&
+                v.endTime <= lastObjectMaxHitTime).length === 0) {
+                continue;
+            }
+            // If this cursor instance doesn't move, it's not the cursor instance we want.
+            if (c.occurrenceGroups.filter((v) => v.moves.length > 0).length ===
+                0) {
+                continue;
+            }
+            cursorIndices.push(i);
+        }
+        const sectionObjects = this.hitObjects.slice(section.firstObjectIndex, section.lastObjectIndex + 1);
+        const sectionReplayObjectData = objectData.slice(section.firstObjectIndex, section.lastObjectIndex + 1);
+        const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
+        for (let i = 0; i < sectionObjects.length && cursorIndices.some((v) => v !== -1); ++i) {
+            const object = sectionObjects[i];
+            const objectData = sectionReplayObjectData[i];
+            if (object instanceof osuBase.Spinner ||
+                objectData.result === exports.HitResult.miss) {
+                continue;
+            }
+            // Exclude sliderbreaks.
+            if (object instanceof osuBase.Slider &&
+                objectData.accuracy === Math.floor(hitWindow50) + 13) {
+                continue;
+            }
+            const objectPosition = object.getStackedPosition(osuBase.Modes.droid);
+            const hitTime = object.startTime + objectData.accuracy;
+            // Observe the cursor position at the object's hit time.
+            for (let j = 0; j < cursorIndices.length; ++j) {
+                if (cursorIndices[j] === -1) {
+                    continue;
+                }
+                const cursorData = this.data.cursorMovement[cursorIndices[j]];
+                const cursorGroup = cursorData.occurrenceGroups.find((v) => v.isActiveAt(hitTime));
+                if (!cursorGroup) {
+                    continue;
+                }
+                const cursors = cursorGroup.allOccurrences;
+                let isInObject = false;
+                for (let k = 1; k < cursors.length; ++k) {
+                    const cursor = cursors[k];
+                    const prevCursor = cursors[k - 1];
+                    // Only consider cursor at interval prev.time <= hitTime <= current.time.
+                    if (prevCursor.time <= hitTime && cursor.time >= hitTime) {
+                        switch (cursor.id) {
+                            case exports.MovementType.up:
+                                isInObject =
+                                    prevCursor.position.getDistance(objectPosition) <= object.radius;
+                                break;
+                            case exports.MovementType.move: {
+                                // Interpolate movement.
+                                const t = (hitTime - prevCursor.time) /
+                                    (cursor.time - prevCursor.time);
+                                const cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
+                                isInObject =
+                                    objectPosition.getDistance(cursorPosition) <= object.radius;
+                            }
+                        }
+                        break;
+                    }
+                }
+                if (!isInObject) {
+                    cursorIndices[j] = -1;
+                }
+            }
+        }
+        return cursorIndices.find((v) => v !== -1) ?? -1;
+    }
+    /**
+     * Creates nerf factors by scanning through objects.
+     */
+    calculateNerfFactors() {
+        for (const beatmapSection of this.beatmapSections) {
+            const cursorAmounts = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+            const cursorVectorTimes = [];
+            for (const object of beatmapSection.objects) {
+                if (object.pressingCursorIndex === -1 ||
+                    object.pressingCursorInstanceIndex ===
+                        beatmapSection.dragFingerIndex) {
+                    continue;
+                }
+                ++cursorAmounts[object.pressingCursorInstanceIndex];
+                const cursor = this.downCursorInstances[object.pressingCursorInstanceIndex][object.pressingCursorIndex];
+                cursorVectorTimes.push({
+                    vector: new osuBase.Vector2(cursor.position.x, cursor.position.y),
+                    time: cursor.time,
+                });
+            }
+            if (beatmapSection.dragFingerIndex !== -1) {
+                // Remove the drag index to prevent it from being picked up into the detection.
+                cursorAmounts.splice(beatmapSection.dragFingerIndex, 1);
+            }
+            // This index will be used to detect if a section is 3-fingered.
+            // If the section is dragged, the dragged instance will be ignored,
+            // hence why the index is 1 less than nondragged section.
+            const fingerSplitIndex = beatmapSection.dragFingerIndex !== -1 ? 2 : 3;
+            // Divide >=4th (3rd for drag) cursor instances with 1st + 2nd (+ 3rd for nondrag)
+            // to check if the section is 3-fingered.
+            const threeFingerRatio = cursorAmounts
+                .slice(fingerSplitIndex)
+                .reduce((acc, value) => acc + value, 0) /
+                Math.max(cursorAmounts
+                    .slice(0, fingerSplitIndex)
+                    .reduce((acc, value) => acc + value, 0), 1);
+            const similarPresses = [];
+            cursorVectorTimes.sort((a, b) => a.time - b.time);
+            for (const cursorVectorTime of cursorVectorTimes) {
+                const pressIndex = similarPresses.findIndex((v) => v.vector.getDistance(cursorVectorTime.vector) <=
+                    this.cursorDistancingDistanceThreshold);
+                if (pressIndex !== -1) {
+                    if (cursorVectorTime.time -
+                        similarPresses[pressIndex].lastTime >=
+                        this.cursorDistancingTimeThreshold) {
+                        // If the previous press is too late, remove it from the
+                        // list and register the current press as a new press.
+                        similarPresses.splice(pressIndex, 1);
+                        similarPresses.push({
+                            vector: cursorVectorTime.vector,
+                            count: 1,
+                            lastTime: cursorVectorTime.time,
+                        });
+                        continue;
+                    }
+                    similarPresses[pressIndex].vector = cursorVectorTime.vector;
+                    similarPresses[pressIndex].lastTime = cursorVectorTime.time;
+                    ++similarPresses[pressIndex].count;
+                }
+                else {
+                    similarPresses.push({
+                        vector: cursorVectorTime.vector,
+                        count: 1,
+                        lastTime: cursorVectorTime.time,
+                    });
+                }
+            }
+            // Sort by highest count; assume the order is 3rd, 4th, 5th, ... finger
+            const threeFingerPresses = similarPresses
+                .filter((v) => v.count >= this.cursorDistancingCountThreshold)
+                .sort((a, b) => b.count - a.count)
+                .slice(fingerSplitIndex);
+            if (threeFingerRatio > this.threeFingerRatioThreshold ||
+                threeFingerPresses.length > 0) {
+                const objectCount = beatmapSection.lastObjectIndex -
+                    beatmapSection.firstObjectIndex +
+                    1;
+                // We can ignore the first 3 (2 for drag) filled cursor instances
+                // since they are guaranteed not 3 finger.
+                const threeFingerCursorAmounts = cursorAmounts
+                    .slice(fingerSplitIndex)
+                    .filter((amount) => amount > 0);
+                // Finger factor applies more penalty if more fingers were used.
+                const fingerFactor = threeFingerRatio > this.threeFingerRatioThreshold
+                    ? threeFingerCursorAmounts.reduce((acc, value, index) => acc +
+                        Math.pow(((index + 1) * value * objectCount) /
+                            this.strainNoteCount, 0.9), 1)
+                    : Math.pow(threeFingerPresses.reduce((acc, value, index) => acc +
+                        Math.pow(((index + 1) *
+                            (value.count /
+                                (this
+                                    .cursorDistancingCountThreshold *
+                                    2)) *
+                            objectCount) /
+                            this.strainNoteCount, 0.2), 1), 0.2);
+                // Length factor applies more penalty if there are more 3-fingered object.
+                const lengthFactor = 1 + Math.pow(objectCount / this.strainNoteCount, 1.2);
+                this.nerfFactors.push({
+                    strainFactor: Math.max(1, beatmapSection.sumStrain),
+                    fingerFactor,
+                    lengthFactor,
+                });
+            }
+        }
+    }
+    /**
+     * Calculates the final penalty.
+     */
+    calculateFinalPenalty() {
+        return this.nerfFactors.reduce((a, n) => a +
+            0.015 *
+                Math.pow(n.strainFactor * n.fingerFactor * n.lengthFactor, 1.05), 1);
+    }
+}
+
 /**
  * Represents a replay data in an osu!droid replay.
  *
@@ -386,10 +954,6 @@ class ThreeFingerChecker {
      * The difficulty attributes of the beatmap.
      */
     difficultyAttributes;
-    /**
-     * The true scale of objects.
-     */
-    trueScale;
     /**
      * The distance threshold between cursors to assume that two cursors are
      * actually pressed with 1 finger in osu!pixels.
@@ -466,20 +1030,16 @@ class ThreeFingerChecker {
         this.beatmap = beatmap;
         this.data = data;
         this.difficultyAttributes = difficultyAttributes;
-        const stats = new osuBase.MapStats({
-            od: this.beatmap.difficulty.od,
+        const od = osuBase.calculateDroidDifficultyStatistics({
+            overallDifficulty: beatmap.difficulty.od,
             mods: this.difficultyAttributes.mods.filter((m) => m.isApplicableToDroid() &&
                 !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
-        }).calculate({ mode: osuBase.Modes.droid, convertDroidOD: false });
+            convertOverallDifficulty: false,
+        }).overallDifficulty;
         this.isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
-        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
+        this.hitWindow = new osuBase.DroidHitWindow(od);
         this.strainNoteCount =
             this.difficultyAttributes.possibleThreeFingeredSections.reduce((a, v) => a + v.lastObjectIndex - v.firstObjectIndex + 1, 0);
-        const circleSize = new osuBase.MapStats({
-            cs: this.beatmap.difficulty.cs,
-            mods: this.difficultyAttributes.mods,
-        }).calculate({ mode: osuBase.Modes.droid }).cs;
-        this.trueScale = (1 - (0.7 * (circleSize - 5)) / 5) / 2;
     }
     /**
      * Checks whether a beatmap is eligible to be detected for 3-finger.
@@ -572,11 +1132,13 @@ class ThreeFingerChecker {
     filterCursorInstances() {
         const { objects } = this.beatmap.hitObjects;
         const objectData = this.data.hitObjectData;
+        const firstObject = objects[0];
+        const lastObject = objects.at(-1);
         const firstObjectResult = objectData[0].result;
         const lastObjectResult = objectData.at(-1).result;
         // For sliders, automatically set hit window length to be as lenient as possible.
         let firstObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
-        if (objects[0] instanceof osuBase.Circle) {
+        if (firstObject instanceof osuBase.Circle) {
             switch (firstObjectResult) {
                 case exports.HitResult.great:
                     firstObjectHitWindow = this.hitWindow.hitWindowFor300(this.isPrecise);
@@ -590,7 +1152,7 @@ class ThreeFingerChecker {
         }
         // For sliders, automatically set hit window length to be as lenient as possible.
         let lastObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
-        if (objects.at(-1) instanceof osuBase.Circle) {
+        if (lastObject instanceof osuBase.Circle) {
             switch (lastObjectResult) {
                 case exports.HitResult.great:
                     lastObjectHitWindow = this.hitWindow.hitWindowFor300(this.isPrecise);
@@ -605,8 +1167,8 @@ class ThreeFingerChecker {
         // These hit time uses hit window length as threshold.
         // This is because cursors aren't recorded exactly at hit time,
         // probably due to the game's behavior.
-        const firstObjectHitTime = objects[0].startTime - firstObjectHitWindow;
-        const lastObjectHitTime = objects.at(-1).startTime + lastObjectHitWindow;
+        const firstObjectHitTime = firstObject.startTime - firstObjectHitWindow;
+        const lastObjectHitTime = lastObject.startTime + lastObjectHitWindow;
         for (let i = 0; i < this.data.cursorMovement.length; ++i) {
             const cursorInstance = this.data.cursorMovement[i];
             const validOccurrences = [];
@@ -728,7 +1290,7 @@ class ThreeFingerChecker {
     findDragIndex(sectionObjects, sectionReplayObjectData, cursorIndexes) {
         const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
         for (let i = 0; i < sectionObjects.length && cursorIndexes.every((v) => v !== -1); ++i) {
-            let object = sectionObjects[i];
+            const object = sectionObjects[i];
             const objectData = sectionReplayObjectData[i];
             if (object instanceof osuBase.Spinner ||
                 objectData.result === exports.HitResult.miss) {
@@ -739,11 +1301,6 @@ class ThreeFingerChecker {
                 objectData.accuracy === Math.floor(hitWindow50) + 13) {
                 continue;
             }
-            if (object.droidScale !== this.trueScale) {
-                // Deep copy the instance so that we can assign scale.
-                object = osuBase.Utils.deepCopy(object);
-                object.droidScale = this.trueScale;
-            }
             const objectPosition = object.getStackedPosition(osuBase.Modes.droid);
             const hitTime = object.startTime + objectData.accuracy;
             // Observe the cursor position at the object's hit time.
@@ -770,7 +1327,7 @@ class ThreeFingerChecker {
                     switch (cursor.id) {
                         case exports.MovementType.up:
                             isInObject =
-                                prevCursor.position.getDistance(objectPosition) <= object.getRadius(osuBase.Modes.droid);
+                                prevCursor.position.getDistance(objectPosition) <= object.radius;
                             break;
                         case exports.MovementType.move:
                             // Interpolate movement.
@@ -781,7 +1338,7 @@ class ThreeFingerChecker {
                                     (cursor.time - prevCursor.time);
                                 const cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
                                 isInObject =
-                                    objectPosition.getDistance(cursorPosition) <= object.getRadius(osuBase.Modes.droid);
+                                    objectPosition.getDistance(cursorPosition) <= object.radius;
                             }
                     }
                     if (!isInObject) {
@@ -952,10 +1509,9 @@ class ThreeFingerChecker {
      * Calculates the final penalty.
      */
     calculateFinalPenalty() {
-        return (1 +
-            this.nerfFactors.reduce((a, n) => a +
-                0.015 *
-                    Math.pow(n.strainFactor * n.fingerFactor * n.lengthFactor, 1.05), 0));
+        return this.nerfFactors.reduce((a, n) => a +
+            0.015 *
+                Math.pow(n.strainFactor * n.fingerFactor * n.lengthFactor, 1.05), 1);
     }
 }
 
@@ -1057,12 +1613,13 @@ class TwoHandChecker {
     constructor(calculator, data) {
         this.calculator = calculator;
         this.data = data;
-        const stats = new osuBase.MapStats({
-            od: this.calculator.beatmap.difficulty.od,
-            mods: this.calculator.mods.filter((m) => m.isApplicableToDroid() &&
+        const od = osuBase.calculateDroidDifficultyStatistics({
+            overallDifficulty: calculator.beatmap.difficulty.od,
+            mods: calculator.mods.filter((m) => m.isApplicableToDroid() &&
                 !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
-        }).calculate({ mode: osuBase.Modes.droid, convertDroidOD: false });
-        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
+            convertOverallDifficulty: false,
+        }).overallDifficulty;
+        this.hitWindow = new osuBase.DroidHitWindow(od);
         this.hitWindow50 = this.hitWindow.hitWindowFor50(calculator.mods.some((m) => m instanceof osuBase.ModPrecise));
         // this.csvString = `Mods,${
         //     data.convertedMods.reduce((a, m) => a + m.acronym, "") || "NM"
@@ -1245,9 +1802,8 @@ class TwoHandChecker {
         const prevToCurrentMovement = object
             .getStackedPosition(osuBase.Modes.droid)
             .subtract(prevObjectEndPosition);
-        const radius = object.getRadius(osuBase.Modes.droid);
         // Don't consider objects that are too close to each other.
-        if (prevToCurrentMovement.length <= radius) {
+        if (prevToCurrentMovement.length <= object.radius) {
             return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
         }
         // The case for a one-handed object is that there will be a slight movement in the cursor towards
@@ -1376,7 +1932,6 @@ class TwoHandChecker {
                 cursorTime: object.startTime,
             };
         }
-        const radius = object.getRadius(osuBase.Modes.droid);
         let hitWindow = this.hitWindow50;
         const isPrecise = this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise);
         // For sliders, set the hit window to as lenient as possible.
@@ -1391,7 +1946,7 @@ class TwoHandChecker {
             }
         }
         // TODO: what to do for head sliderbreaks?
-        let nearestPosition = new osuBase.Vector2(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+        let nearestPosition = new osuBase.Vector2(Number.POSITIVE_INFINITY);
         let nearestCursorIndex = 0;
         let nearestGroupIndex = 0;
         let nearestCursorGroupIndex = 0;
@@ -1399,12 +1954,12 @@ class TwoHandChecker {
         const minimumActiveTime = object.startTime - hitWindow;
         const maximumActiveTime = object.startTime + hitWindow;
         for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            if (nearestPosition.getDistance(objectPosition) <= radius) {
+            if (nearestPosition.getDistance(objectPosition) <= object.radius) {
                 break;
             }
             const cursorData = this.data.cursorMovement[i];
             for (let j = 0; j < cursorData.occurrenceGroups.length; ++j) {
-                if (nearestPosition.getDistance(objectPosition) <= radius) {
+                if (nearestPosition.getDistance(objectPosition) <= object.radius) {
                     break;
                 }
                 const cursorGroup = cursorData.occurrenceGroups[j];
@@ -1416,7 +1971,8 @@ class TwoHandChecker {
                 }
                 // Validate the down press first.
                 const { down } = cursorGroup;
-                if (down.position.getDistance(objectPosition) <= radius &&
+                if (down.position.getDistance(objectPosition) <=
+                    object.radius &&
                     Math.abs(down.time - object.startTime) <= hitWindow) {
                     if (objectIndex > 0) {
                         const prevObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
@@ -1487,12 +2043,13 @@ class TwoHandChecker {
                                 nearestCursorGroupIndex = k;
                                 nearestCursorTime = cursorGroup.down.time;
                             }
-                            if (distance <= radius) {
+                            if (distance <= object.radius) {
                                 break;
                             }
                         }
                     }
-                    if (nearestPosition.getDistance(objectPosition) <= radius) {
+                    if (nearestPosition.getDistance(objectPosition) <=
+                        object.radius) {
                         break;
                     }
                 }
@@ -1540,7 +2097,7 @@ class TwoHandChecker {
         else {
             objectEndPosition = object.getStackedPosition(osuBase.Modes.droid);
         }
-        let nearestPosition = new osuBase.Vector2(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+        let nearestPosition = new osuBase.Vector2(Number.POSITIVE_INFINITY);
         let nearestCursorIndex = 0;
         let nearestGroupIndex = 0;
         let nearestCursorGroupIndex = 0;
@@ -1665,12 +2222,13 @@ class SliderCheeseChecker {
         this.beatmap = beatmap;
         this.data = data;
         this.difficultyAttributes = difficultyAttributes;
-        const stats = new osuBase.MapStats({
-            od: this.beatmap.difficulty.od,
+        const od = osuBase.calculateDroidDifficultyStatistics({
+            overallDifficulty: beatmap.difficulty.od,
             mods: this.difficultyAttributes.mods.filter((m) => m.isApplicableToDroid() &&
                 !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
-        }).calculate({ mode: osuBase.Modes.droid, convertDroidOD: false });
-        this.hitWindow50 = new osuBase.DroidHitWindow(stats.od).hitWindowFor50(this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise));
+            convertOverallDifficulty: false,
+        }).overallDifficulty;
+        this.hitWindow50 = new osuBase.DroidHitWindow(od).hitWindowFor50(this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise));
     }
     /**
      * Checks if relevant sliders in the given beatmap was cheesed.
@@ -1697,12 +2255,7 @@ class SliderCheeseChecker {
         const cheesedDifficultyRatings = [];
         // Current loop indices are stored for efficiency.
         const cursorLoopIndices = osuBase.Utils.initializeArray(10, 0);
-        const circleSize = new osuBase.MapStats({
-            cs: this.beatmap.difficulty.cs,
-            mods: this.difficultyAttributes.mods,
-        }).calculate({ mode: osuBase.Modes.droid }).cs;
-        const scale = osuBase.CircleSizeCalculator.standardCSToStandardScale(circleSize);
-        const acceptableRadius = 64 * scale * 2.4;
+        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()
@@ -1716,12 +2269,7 @@ class SliderCheeseChecker {
                 objectData.accuracy === Math.floor(this.hitWindow50) + 13) {
                 continue;
             }
-            let object = objects[difficultSlider.index];
-            if (object.droidScale !== scale) {
-                // Deep clone the object so that we can assign scale properly.
-                object = osuBase.Utils.deepCopy(object);
-                object.droidScale = scale;
-            }
+            const object = objects[difficultSlider.index];
             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
@@ -1820,14 +2368,6 @@ class SliderCheeseChecker {
                     continue;
                 }
                 const nestedObject = object.nestedHitObjects[i];
-                nestedObject.droidScale = scale;
-                // Special treatment for slider tail where its treated as a "legacy tail" in osu!standard.
-                // In that case, its time is assumed to be 36ms behind the slider's end time. However, that
-                // is not the case for osu!droid.
-                if (nestedObject instanceof osuBase.SliderTail) {
-                    nestedObject.startTime = object.endTime;
-                    nestedObject.endTime = object.endTime;
-                }
                 const nestedPosition = nestedObject.getStackedPosition(osuBase.Modes.droid);
                 while (occurrenceLoopIndex < allOccurrences.length &&
                     allOccurrences[occurrenceLoopIndex].time <
@@ -1944,13 +2484,14 @@ class ReplayAnalyzer {
      */
     hasBeenCheckedFor2Hand = false;
     /**
-     * Whether this repla has been checked against slider cheesing.
+     * Whether this replay has been checked against slider cheesing.
      */
     hasBeenCheckedForSliderCheesing = false;
     /**
      * The amount of two-handed objects.
      */
     twoHandedNoteCount = 0;
+    convertedBeatmap;
     // Sizes of primitive data types in Java (in bytes)
     BYTE_LENGTH = 1;
     SHORT_LENGTH = 2;
@@ -2302,12 +2843,12 @@ class ReplayAnalyzer {
             this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
             ? this.beatmap.beatmap
             : this.beatmap;
-        const objects = beatmap.hitObjects.objects;
-        const stats = new osuBase.MapStats({
-            od: beatmap.difficulty.od,
+        const { objects } = beatmap.hitObjects;
+        const od = osuBase.calculateDroidDifficultyStatistics({
+            overallDifficulty: beatmap.difficulty.od,
             mods: this.data.convertedMods.filter((m) => !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
-        }).calculate();
-        const hitWindow50 = new osuBase.DroidHitWindow(stats.od).hitWindowFor50(this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise));
+        }).overallDifficulty;
+        const hitWindow50 = new osuBase.DroidHitWindow(od).hitWindowFor50(this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise));
         // The accuracy of sliders is set to (50 hit window)ms + 13ms if their head was not hit:
         // https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/Slider.java#L821
         //
@@ -2321,8 +2862,8 @@ class ReplayAnalyzer {
                 accuracies.push(0);
                 continue;
             }
-            const accuracy = v.accuracy;
-            if (o instanceof osuBase.Slider && v.accuracy === sliderbreakHitOffset) {
+            const { accuracy } = v;
+            if (o instanceof osuBase.Slider && accuracy === sliderbreakHitOffset) {
                 accuracies.push(0);
                 continue;
             }
@@ -2385,9 +2926,32 @@ class ReplayAnalyzer {
         if (!this.beatmap || !this.data || !this.difficultyAttributes) {
             return;
         }
-        const threeFingerChecker = new ThreeFingerChecker(this.beatmap instanceof osuBase.Beatmap
-            ? this.beatmap
-            : this.beatmap.beatmap, this.data, this.difficultyAttributes);
+        if (!this.convertedBeatmap) {
+            const mods = this.data.convertedMods.slice();
+            if ([
+                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,
+                }));
+            }
+            this.convertedBeatmap ??= new osuBase.BeatmapConverter(this.beatmap instanceof osuBase.Beatmap
+                ? this.beatmap
+                : this.beatmap.beatmap).convert({
+                mode: osuBase.Modes.droid,
+                mods: mods,
+                customSpeedMultiplier: this.data.speedMultiplier,
+            });
+        }
+        const threeFingerChecker = this.difficultyAttributes.mode === "rebalance"
+            ? new RebalanceThreeFingerChecker(this.convertedBeatmap, this.data, this.difficultyAttributes)
+            : new ThreeFingerChecker(this.convertedBeatmap, this.data, this.difficultyAttributes);
         const result = threeFingerChecker.check();
         this.is3Finger = result.is3Finger;
         this.tapPenalty = result.penalty;
@@ -2419,9 +2983,30 @@ class ReplayAnalyzer {
         if (!this.beatmap || !this.data || !this.difficultyAttributes) {
             return;
         }
-        const sliderCheeseChecker = new SliderCheeseChecker(this.beatmap instanceof osuBase.Beatmap
-            ? this.beatmap
-            : this.beatmap.beatmap, this.data, this.difficultyAttributes);
+        if (!this.convertedBeatmap) {
+            const mods = this.data.convertedMods.slice();
+            if ([
+                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,
+                }));
+            }
+            this.convertedBeatmap ??= new osuBase.BeatmapConverter(this.beatmap instanceof osuBase.Beatmap
+                ? this.beatmap
+                : this.beatmap.beatmap).convert({
+                mode: osuBase.Modes.droid,
+                mods: mods,
+                customSpeedMultiplier: this.data.speedMultiplier,
+            });
+        }
+        const sliderCheeseChecker = new SliderCheeseChecker(this.convertedBeatmap, this.data, this.difficultyAttributes);
         this.sliderCheesePenalty = sliderCheeseChecker.check();
         this.hasBeenCheckedForSliderCheesing = true;
     }
@@ -2472,6 +3057,7 @@ class ReplayObjectData {
 exports.CursorData = CursorData;
 exports.CursorOccurrence = CursorOccurrence;
 exports.CursorOccurrenceGroup = CursorOccurrenceGroup;
+exports.RebalanceThreeFingerChecker = RebalanceThreeFingerChecker;
 exports.ReplayAnalyzer = ReplayAnalyzer;
 exports.ReplayData = ReplayData;
 exports.ReplayObjectData = ReplayObjectData;