@rian8337/osu-droid-replay-analyzer 3.2.0 → 4.0.0-beta.0

package/dist/index.js

@@ -1,16 +1,13 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 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 stream = require('stream');
+var node_stream = require('node:stream');
 
-function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
+function _interopNamespaceDefault(e) {
     var n = Object.create(null);
     if (e) {
         Object.keys(e).forEach(function (k) {
@@ -23,11 +20,11 @@ function _interopNamespace(e) {
             }
         });
     }
-    n["default"] = e;
+    n.default = e;
     return Object.freeze(n);
 }
 
-var javaDeserialization__namespace = /*#__PURE__*/_interopNamespace(javaDeserialization);
+var javaDeserialization__namespace = /*#__PURE__*/_interopNamespaceDefault(javaDeserialization);
 
 /**
  * Movement types of a cursor in an osu!droid replay.
@@ -365,104 +362,22 @@ class ReplayData {
     }
 }
 
-/**
- * A beatmap section generator that generates beatmap section based on aim/speed strain.
- */
-class BeatmapSectionGenerator {
-    /**
-     * Generates `BeatmapSection`s for the specified beatmap.
-     *
-     * @param calculator The difficulty calculator to generate for.
-     * @param minSectionObjectCount The maximum delta time allowed between two beatmap sections.
-     * Increasing this number decreases the amount of beatmap sections in general. Note that this value does not account for the speed multiplier of
-     * the play, similar to the way replay object data is stored.
-     * @param maxSectionDeltaTime The minimum object count required to make a beatmap section. Increasing this number decreases the amount of beatmap sections.
-     */
-    static generateSections(calculator, minSectionObjectCount, maxSectionDeltaTime) {
-        const beatmapSections = [];
-        let firstObjectIndex = 0;
-        for (let i = 0; i < calculator.objects.length - 1; ++i) {
-            const current = calculator.objects[i];
-            const next = calculator.objects[i + 1];
-            const realDeltaTime = next.object.startTime - current.object.endTime;
-            if (realDeltaTime >= maxSectionDeltaTime) {
-                // Ignore sections that don't meet object count requirement.
-                if (i - firstObjectIndex < minSectionObjectCount) {
-                    firstObjectIndex = i + 1;
-                    continue;
-                }
-                beatmapSections.push({
-                    firstObjectIndex,
-                    lastObjectIndex: i,
-                });
-                firstObjectIndex = i + 1;
-            }
-        }
-        // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
-        if (calculator.objects.length - firstObjectIndex >
-            minSectionObjectCount) {
-            beatmapSections.push({
-                firstObjectIndex,
-                lastObjectIndex: calculator.objects.length - 1,
-            });
-        }
-        return beatmapSections;
-    }
-}
-
-/**
- * Represents a section of a beatmap.
- */
-class BeatmapSection {
-    /**
-     * The index of the first `DifficultyHitObject` of this beatmap section.
-     */
-    firstObjectIndex;
-    /**
-     * The index of the last `DifficultyHitObject` of this beatmap section.
-     */
-    lastObjectIndex;
-    /**
-     * @param firstObjectIndex The index of the first `DifficultyHitObject` of this beatmap section.
-     * @param lastObjectIndex The index of the last `DifficultyHitObject` of this beatmap section.
-     */
-    constructor(firstObjectIndex, lastObjectIndex) {
-        this.firstObjectIndex = firstObjectIndex;
-        this.lastObjectIndex = lastObjectIndex;
-    }
-}
-
-/**
- * A section of a beatmap with extra information used for detecting three-finger usage.
- */
-class ThreeFingerBeatmapSection extends BeatmapSection {
-    /**
-     * Whether or not this beatmap section is dragged.
-     */
-    isDragged;
-    /**
-     * The index of the cursor that is dragging this section.
-     */
-    dragFingerIndex;
-    constructor(values) {
-        super(values.firstObjectIndex, values.lastObjectIndex);
-        this.isDragged = values.isDragged;
-        this.dragFingerIndex = values.dragFingerIndex;
-    }
-}
-
 /**
  * Utility to check whether or not a beatmap is three-fingered.
  */
 class ThreeFingerChecker {
     /**
-     * The difficulty calculator that is being analyzed.
+     * The beatmap that is being analyzed.
      */
-    calculator;
+    beatmap;
     /**
      * The data of the replay.
      */
     data;
+    /**
+     * The difficulty attributes of the beatmap.
+     */
+    difficultyAttributes;
     /**
      * The strain threshold to start detecting for 3-fingered section.
      *
@@ -500,22 +415,7 @@ class ThreeFingerChecker {
      */
     threeFingerRatioThreshold = 0.01;
     /**
-     * The maximum delta time allowed between two beatmap sections.
-     *
-     * Increasing this number decreases the amount of beatmap sections in general.
-     *
-     * Note that this value does not account for the speed multiplier of
-     * the play, similar to the way replay object data is stored.
-     */
-    maxSectionDeltaTime = 2000;
-    /**
-     * The minimum object count required to make a beatmap section.
-     *
-     * Increasing this number decreases the amount of beatmap sections.
-     */
-    minSectionObjectCount = 5;
-    /**
-     * The sections of the beatmap that was cut based on `maxSectionDeltaTime` and `minSectionObjectCount`.
+     * Extended sections of the beatmap for drag detection.
      */
     beatmapSections = [];
     /**
@@ -543,38 +443,40 @@ class ThreeFingerChecker {
      * Each index represents the cursor index.
      */
     downCursorInstances = [];
-    /**
-     * All cursor occurrences in the replay.
-     *
-     * Each index represents the cursor index.
-     */
-    allCursorInstances;
     /**
      * Nerf factors from all sections that were three-fingered.
      */
     nerfFactors = [];
     /**
-     * @param calculator The difficulty calculator to analyze.
+     * 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(calculator, data) {
-        this.calculator = calculator;
+    constructor(beatmap, data, difficultyAttributes) {
+        this.beatmap = beatmap;
         this.data = data;
-        this.allCursorInstances = data.cursorMovement.map((v) => v.allOccurrences);
+        this.difficultyAttributes = difficultyAttributes;
         const stats = new osuBase.MapStats({
-            od: this.calculator.beatmap.difficulty.od,
-            mods: this.calculator.mods.filter((m) => m.isApplicableToDroid() &&
+            od: this.beatmap.difficulty.od,
+            mods: this.difficultyAttributes.mods.filter((m) => m.isApplicableToDroid() &&
                 !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
         }).calculate();
+        this.isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
         this.hitWindow = new osuBase.DroidHitWindow(stats.od);
-        const strainNotes = (calculator.objects).filter((v) => v.originalTapStrain >= ThreeFingerChecker.strainThreshold);
-        this.strainNoteCount = strainNotes.length;
+        this.strainNoteCount =
+            this.difficultyAttributes.possibleThreeFingeredSections.reduce((a, v) => a + v.lastObjectIndex - v.firstObjectIndex + 1, 0);
     }
     /**
      * Checks whether a beatmap is eligible to be detected for 3-finger.
+     *
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
-    static isEligibleToDetect(map) {
-        return map.objects.some((v) => v.originalTapStrain >= this.strainThreshold);
+    static isEligibleToDetect(difficultyAttributes) {
+        return difficultyAttributes.possibleThreeFingeredSections.length > 0;
     }
     /**
      * Checks if the given beatmap is 3-fingered and also returns the final penalty.
@@ -597,7 +499,6 @@ class ThreeFingerChecker {
         }
         this.getBeatmapSections();
         this.detectDragPlay();
-        this.getDetailedBeatmapSections();
         this.preventAccidentalTaps();
         if (this.downCursorInstances.filter((v) => v.length > 0).length <= 3) {
             return { is3Finger: false, penalty: 1 };
@@ -613,50 +514,43 @@ class ThreeFingerChecker {
      * start of the hitobject before it and do not end right at the first hitobject after it.
      */
     getAccurateBreakPoints() {
-        const objects = this.calculator.objects;
+        const { objects } = this.beatmap.hitObjects;
         const objectData = this.data.hitObjectData;
-        const isPrecise = this.calculator.mods.some((m) => m instanceof osuBase.ModPrecise);
-        for (const breakPoint of this.calculator.beatmap.events.breaks) {
-            const beforeIndex = osuBase.MathUtils.clamp(objects.findIndex((o) => o.object.endTime >= breakPoint.startTime) - 1, 0, objects.length - 2);
-            let timeBefore = objects[beforeIndex].object.endTime;
+        for (const breakPoint of this.beatmap.events.breaks) {
+            const beforeIndex = osuBase.MathUtils.clamp(objects.findIndex((o) => o.endTime >= breakPoint.startTime) - 1, 0, objects.length - 2);
+            let timeBefore = objects[beforeIndex].endTime;
             // For sliders and spinners, automatically set hit window length to be as lenient as possible.
-            let beforeIndexHitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
+            let beforeIndexHitWindowLength = this.hitWindow.hitWindowFor50(this.isPrecise);
             switch (objectData[beforeIndex].result) {
                 case exports.HitResult.great:
-                    beforeIndexHitWindowLength =
-                        this.hitWindow.hitWindowFor300(isPrecise);
+                    beforeIndexHitWindowLength = this.hitWindow.hitWindowFor300(this.isPrecise);
                     break;
                 case exports.HitResult.good:
-                    beforeIndexHitWindowLength =
-                        this.hitWindow.hitWindowFor100(isPrecise);
+                    beforeIndexHitWindowLength = this.hitWindow.hitWindowFor100(this.isPrecise);
                     break;
                 default:
-                    beforeIndexHitWindowLength =
-                        this.hitWindow.hitWindowFor50(isPrecise);
+                    beforeIndexHitWindowLength = this.hitWindow.hitWindowFor50(this.isPrecise);
             }
             timeBefore += beforeIndexHitWindowLength;
             const afterIndex = beforeIndex + 1;
-            let timeAfter = objects[afterIndex].object.startTime;
+            let timeAfter = objects[afterIndex].startTime;
             // For sliders and spinners, automatically set hit window length to be as lenient as possible.
-            let afterIndexHitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
+            let afterIndexHitWindowLength = this.hitWindow.hitWindowFor50(this.isPrecise);
             switch (objectData[afterIndex].result) {
                 case exports.HitResult.great:
-                    afterIndexHitWindowLength =
-                        this.hitWindow.hitWindowFor300(isPrecise);
+                    afterIndexHitWindowLength = this.hitWindow.hitWindowFor300(this.isPrecise);
                     break;
                 case exports.HitResult.good:
-                    afterIndexHitWindowLength =
-                        this.hitWindow.hitWindowFor100(isPrecise);
+                    afterIndexHitWindowLength = this.hitWindow.hitWindowFor100(this.isPrecise);
                     break;
                 default:
-                    afterIndexHitWindowLength =
-                        this.hitWindow.hitWindowFor50(isPrecise);
+                    afterIndexHitWindowLength = this.hitWindow.hitWindowFor50(this.isPrecise);
             }
             timeAfter += afterIndexHitWindowLength;
-            this.breakPointAccurateTimes.push({
+            this.breakPointAccurateTimes.push(new osuBase.BreakPoint({
                 startTime: timeBefore,
                 endTime: timeAfter,
-            });
+            }));
         }
     }
     /**
@@ -665,50 +559,43 @@ class ThreeFingerChecker {
      * This also filters cursors that are in break period or happen before start/after end of the beatmap.
      */
     filterCursorInstances() {
-        const objects = this.calculator.objects;
+        const { objects } = this.beatmap.hitObjects;
         const objectData = this.data.hitObjectData;
         const firstObjectResult = objectData[0].result;
         const lastObjectResult = objectData.at(-1).result;
-        const isPrecise = this.calculator.mods.some((m) => m instanceof osuBase.ModPrecise);
         // For sliders, automatically set hit window length to be as lenient as possible.
-        let firstObjectHitWindow = this.hitWindow.hitWindowFor50(isPrecise);
-        if (objects[0].object instanceof osuBase.Circle) {
+        let firstObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
+        if (objects[0] instanceof osuBase.Circle) {
             switch (firstObjectResult) {
                 case exports.HitResult.great:
-                    firstObjectHitWindow =
-                        this.hitWindow.hitWindowFor300(isPrecise);
+                    firstObjectHitWindow = this.hitWindow.hitWindowFor300(this.isPrecise);
                     break;
                 case exports.HitResult.good:
-                    firstObjectHitWindow =
-                        this.hitWindow.hitWindowFor100(isPrecise);
+                    firstObjectHitWindow = this.hitWindow.hitWindowFor100(this.isPrecise);
                     break;
                 default:
-                    firstObjectHitWindow =
-                        this.hitWindow.hitWindowFor50(isPrecise);
+                    firstObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
             }
         }
         // For sliders, automatically set hit window length to be as lenient as possible.
-        let lastObjectHitWindow = this.hitWindow.hitWindowFor50(isPrecise);
-        if (objects.at(-1).object instanceof osuBase.Circle) {
+        let lastObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
+        if (objects.at(-1) instanceof osuBase.Circle) {
             switch (lastObjectResult) {
                 case exports.HitResult.great:
-                    lastObjectHitWindow =
-                        this.hitWindow.hitWindowFor300(isPrecise);
+                    lastObjectHitWindow = this.hitWindow.hitWindowFor300(this.isPrecise);
                     break;
                 case exports.HitResult.good:
-                    lastObjectHitWindow =
-                        this.hitWindow.hitWindowFor100(isPrecise);
+                    lastObjectHitWindow = this.hitWindow.hitWindowFor100(this.isPrecise);
                     break;
                 default:
-                    lastObjectHitWindow =
-                        this.hitWindow.hitWindowFor50(isPrecise);
+                    lastObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
             }
         }
         // 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].object.startTime - firstObjectHitWindow;
-        const lastObjectHitTime = objects.at(-1).object.startTime + lastObjectHitWindow;
+        const firstObjectHitTime = objects[0].startTime - firstObjectHitWindow;
+        const lastObjectHitTime = objects.at(-1).startTime + lastObjectHitWindow;
         for (let i = 0; i < this.data.cursorMovement.length; ++i) {
             const cursorInstance = this.data.cursorMovement[i];
             const validOccurrences = [];
@@ -732,14 +619,13 @@ class ThreeFingerChecker {
      * detect dragged sections and improve detection speed.
      */
     getBeatmapSections() {
-        const beatmapSections = BeatmapSectionGenerator.generateSections(this.calculator, this.minSectionObjectCount, this.maxSectionDeltaTime);
-        for (const beatmapSection of beatmapSections) {
-            this.beatmapSections.push(new ThreeFingerBeatmapSection({
-                firstObjectIndex: beatmapSection.firstObjectIndex,
-                lastObjectIndex: beatmapSection.lastObjectIndex,
+        for (const section of this.difficultyAttributes
+            .possibleThreeFingeredSections) {
+            this.beatmapSections.push({
+                ...section,
                 isDragged: false,
                 dragFingerIndex: -1,
-            }));
+            });
         }
     }
     /**
@@ -760,48 +646,41 @@ class ThreeFingerChecker {
      * @param section The section to check.
      */
     checkDrag(section) {
-        const objects = this.calculator.objects;
+        const { objects } = this.beatmap.hitObjects;
         const objectData = this.data.hitObjectData;
-        const isPrecise = this.calculator.mods.some((m) => m instanceof osuBase.ModPrecise);
         const firstObject = objects[section.firstObjectIndex];
         const lastObject = objects[section.lastObjectIndex];
-        let firstObjectMinHitTime = firstObject.object.startTime;
-        if (firstObject.object instanceof osuBase.Circle) {
+        let firstObjectMinHitTime = firstObject.startTime;
+        if (firstObject instanceof osuBase.Circle) {
             switch (objectData[section.firstObjectIndex].result) {
                 case exports.HitResult.great:
-                    firstObjectMinHitTime -=
-                        this.hitWindow.hitWindowFor300(isPrecise);
+                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor300(this.isPrecise);
                     break;
                 case exports.HitResult.good:
-                    firstObjectMinHitTime -=
-                        this.hitWindow.hitWindowFor100(isPrecise);
+                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor100(this.isPrecise);
                     break;
                 default:
-                    firstObjectMinHitTime -=
-                        this.hitWindow.hitWindowFor50(isPrecise);
+                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
             }
         }
         else {
-            firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(isPrecise);
+            firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
         }
-        let lastObjectMaxHitTime = lastObject.object.startTime;
-        if (lastObject.object instanceof osuBase.Circle) {
+        let lastObjectMaxHitTime = lastObject.startTime;
+        if (lastObject instanceof osuBase.Circle) {
             switch (objectData[section.lastObjectIndex].result) {
                 case exports.HitResult.great:
-                    lastObjectMaxHitTime +=
-                        this.hitWindow.hitWindowFor300(isPrecise);
+                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor300(this.isPrecise);
                     break;
                 case exports.HitResult.good:
-                    lastObjectMaxHitTime +=
-                        this.hitWindow.hitWindowFor100(isPrecise);
+                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor100(this.isPrecise);
                     break;
                 default:
-                    lastObjectMaxHitTime +=
-                        this.hitWindow.hitWindowFor50(isPrecise);
+                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(this.isPrecise);
             }
         }
         else {
-            lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(isPrecise);
+            lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(this.isPrecise);
         }
         // Since there may be more than 1 cursor instance index,
         // we check which cursor instance follows hitobjects all over.
@@ -834,22 +713,21 @@ class ThreeFingerChecker {
      * @param cursorIndexes The indexes of the cursor instance that has at least an occurrence in the section.
      */
     findDragIndex(sectionObjects, sectionReplayObjectData, cursorIndexes) {
-        const isPrecise = this.calculator.mods.some((m) => m instanceof osuBase.ModPrecise);
-        const hitWindow50 = this.hitWindow.hitWindowFor50(isPrecise);
+        const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
         for (let i = 0; i < sectionObjects.length && cursorIndexes.every((v) => v !== -1); ++i) {
             const object = sectionObjects[i];
             const objectData = sectionReplayObjectData[i];
-            if (object.object instanceof osuBase.Spinner ||
+            if (object instanceof osuBase.Spinner ||
                 objectData.result === exports.HitResult.miss) {
                 continue;
             }
             // Exclude sliderbreaks.
-            if (object.object instanceof osuBase.Slider &&
+            if (object instanceof osuBase.Slider &&
                 objectData.accuracy === Math.floor(hitWindow50) + 13) {
                 continue;
             }
-            const objectPosition = object.object.getStackedPosition(osuBase.Modes.droid);
-            const hitTime = object.object.startTime + objectData.accuracy;
+            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 < cursorIndexes.length; ++j) {
                 if (cursorIndexes[j] === -1) {
@@ -864,30 +742,28 @@ class ThreeFingerChecker {
                 for (let k = 1; k < cursors.length; ++k) {
                     const cursor = cursors[k];
                     const prevCursor = cursors[k - 1];
-                    if (prevCursor.time <
-                        object.object.startTime - hitWindow50) {
+                    if (prevCursor.time < object.startTime - hitWindow50) {
                         continue;
                     }
-                    if (prevCursor.time >
-                        object.object.startTime + hitWindow50) {
+                    if (prevCursor.time > object.startTime + hitWindow50) {
                         break;
                     }
                     let isInObject = false;
                     switch (cursor.id) {
                         case exports.MovementType.up:
                             isInObject =
-                                prevCursor.position.getDistance(objectPosition) <= object.object.getRadius(osuBase.Modes.droid);
+                                prevCursor.position.getDistance(objectPosition) <= object.getRadius(osuBase.Modes.droid);
                             break;
                         case exports.MovementType.move:
                             // Interpolate movement.
                             for (let mSecPassed = prevCursor.time; !isInObject &&
                                 mSecPassed <=
-                                    Math.min(cursor.time, object.object.startTime + hitWindow50); ++mSecPassed) {
+                                    Math.min(cursor.time, object.startTime + hitWindow50); ++mSecPassed) {
                                 const t = (mSecPassed - 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.object.getRadius(osuBase.Modes.droid);
+                                    objectPosition.getDistance(cursorPosition) <= object.getRadius(osuBase.Modes.droid);
                             }
                     }
                     if (!isInObject) {
@@ -898,51 +774,6 @@ class ThreeFingerChecker {
         }
         return cursorIndexes.find((v) => v !== -1) ?? -1;
     }
-    /**
-     * Redivides the beatmap into sections.
-     *
-     * The result will be used to detect for three-fingered
-     * sections.
-     */
-    getDetailedBeatmapSections() {
-        const objects = this.calculator.objects;
-        const newBeatmapSections = [];
-        for (const beatmapSection of this.beatmapSections) {
-            let inSpeedSection = false;
-            let newFirstObjectIndex = beatmapSection.firstObjectIndex;
-            for (let i = beatmapSection.firstObjectIndex; i <= beatmapSection.lastObjectIndex; ++i) {
-                if (!inSpeedSection &&
-                    objects[i].originalTapStrain >=
-                        ThreeFingerChecker.strainThreshold) {
-                    inSpeedSection = true;
-                    newFirstObjectIndex = i;
-                    continue;
-                }
-                if (inSpeedSection &&
-                    objects[i].originalTapStrain <
-                        ThreeFingerChecker.strainThreshold) {
-                    inSpeedSection = false;
-                    newBeatmapSections.push({
-                        firstObjectIndex: newFirstObjectIndex,
-                        lastObjectIndex: i,
-                        isDragged: beatmapSection.isDragged,
-                        dragFingerIndex: beatmapSection.dragFingerIndex,
-                    });
-                }
-            }
-            // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
-            if (inSpeedSection) {
-                newBeatmapSections.push({
-                    firstObjectIndex: newFirstObjectIndex,
-                    lastObjectIndex: beatmapSection.lastObjectIndex,
-                    isDragged: beatmapSection.isDragged,
-                    dragFingerIndex: beatmapSection.dragFingerIndex,
-                });
-            }
-        }
-        this.beatmapSections.length = 0;
-        this.beatmapSections.push(...newBeatmapSections);
-    }
     /**
      * Attempts to prevent accidental taps from being flagged.
      *
@@ -955,7 +786,7 @@ class ThreeFingerChecker {
         if (filledCursorAmount <= 3) {
             return;
         }
-        const objects = this.calculator.objects;
+        const { objects } = this.beatmap.hitObjects;
         const totalCursorAmount = this.downCursorInstances.reduce((acc, value) => acc + value.length, 0);
         for (let i = 0; i < this.downCursorInstances.length; ++i) {
             if (filledCursorAmount <= 3) {
@@ -979,23 +810,22 @@ class ThreeFingerChecker {
      * This check will ignore all objects with speed strain below `strainThreshold`.
      */
     calculateNerfFactors() {
-        const objects = this.calculator.objects;
+        const { objects } = this.beatmap.hitObjects;
         const objectData = this.data.hitObjectData;
-        const isPrecise = this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise);
         // We only filter cursor instances that are above the strain threshold.
         // This minimalizes the amount of cursor instances to analyze.
         for (const beatmapSection of this.beatmapSections) {
             const dragIndex = beatmapSection.dragFingerIndex;
-            const startTime = objects[beatmapSection.firstObjectIndex].object.startTime +
+            const startTime = objects[beatmapSection.firstObjectIndex].startTime +
                 (objectData[beatmapSection.firstObjectIndex].result !==
                     exports.HitResult.miss
                     ? objectData[beatmapSection.firstObjectIndex].accuracy
-                    : -this.hitWindow.hitWindowFor50(isPrecise));
-            const endTime = objects[beatmapSection.lastObjectIndex].object.endTime +
+                    : -this.hitWindow.hitWindowFor50(this.isPrecise));
+            const endTime = objects[beatmapSection.lastObjectIndex].endTime +
                 (objectData[beatmapSection.lastObjectIndex].result !==
                     exports.HitResult.miss
                     ? objectData[beatmapSection.lastObjectIndex].accuracy
-                    : this.hitWindow.hitWindowFor50(isPrecise));
+                    : this.hitWindow.hitWindowFor50(this.isPrecise));
             const cursorAmounts = [];
             const cursorVectorTimes = [];
             for (let i = 0; i < this.downCursorInstances.length; ++i) {
@@ -1071,11 +901,6 @@ class ThreeFingerChecker {
                 const objectCount = beatmapSection.lastObjectIndex -
                     beatmapSection.firstObjectIndex +
                     1;
-                const strainFactor = Math.pow(objects
-                    .slice(beatmapSection.firstObjectIndex, beatmapSection.lastObjectIndex)
-                    .reduce((acc, value) => acc +
-                    value.originalTapStrain /
-                        ThreeFingerChecker.strainThreshold, 0), 0.75);
                 // We can ignore the first 3 (2 for drag) filled cursor instances
                 // since they are guaranteed not 3 finger.
                 const threeFingerCursorAmounts = cursorAmounts
@@ -1097,7 +922,7 @@ class ThreeFingerChecker {
                 // 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, strainFactor),
+                    strainFactor: Math.max(1, beatmapSection.sumStrain),
                     fingerFactor,
                     lengthFactor,
                 });
@@ -1797,48 +1622,46 @@ class TwoHandChecker {
  */
 class SliderCheeseChecker {
     /**
-     * The difficulty calculator that is being analyzed.
+     * The beatmap that is being analyzed.
      */
-    calculator;
+    beatmap;
     /**
      * The data of the replay.
      */
     data;
     /**
-     * The osu!droid hitwindow of the analyzed beatmap.
+     * The difficulty attributes of the beatmap.
      */
-    hitWindow;
+    difficultyAttributes;
     /**
      * The 50 osu!droid hit window of the analyzed beatmap.
      */
     hitWindow50;
     /**
-     * The indexes of objects that were cheesed.
+     * The difficulty ratings of sliders that were cheesed.
      */
-    cheesedObjectIndexes = [];
+    cheesedDifficultyRatings = [];
     /**
-     * @param calculator The difficulty calculator to analyze.
+     * @param beatmap The beatmap to analyze.
      * @param data The data of the replay.
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
-    constructor(calculator, data) {
-        this.calculator = calculator;
+    constructor(beatmap, data, difficultyAttributes) {
+        this.beatmap = beatmap;
         this.data = data;
+        this.difficultyAttributes = difficultyAttributes;
         const stats = new osuBase.MapStats({
-            od: this.calculator.beatmap.difficulty.od,
-            mods: this.calculator.mods.filter((m) => m.isApplicableToDroid() &&
+            od: this.beatmap.difficulty.od,
+            mods: this.difficultyAttributes.mods.filter((m) => m.isApplicableToDroid() &&
                 !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
         }).calculate();
-        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
-        this.hitWindow50 = this.hitWindow.hitWindowFor50(calculator.mods.some((m) => m instanceof osuBase.ModPrecise));
+        this.hitWindow50 = new osuBase.DroidHitWindow(stats.od).hitWindowFor50(this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise));
     }
     /**
      * Checks if relevant sliders in the given beatmap was cheesed.
-     *
-     * Returns a number that can be passed to a `DroidPerformanceCalculator`
-     * to alter the aim performance value.
      */
     check() {
-        if (this.calculator.attributes.sliderCount === 0) {
+        if (this.difficultyAttributes.difficultSliders.length === 0) {
             return {
                 aimPenalty: 1,
                 flashlightPenalty: 1,
@@ -1854,17 +1677,15 @@ class SliderCheeseChecker {
     checkSliderCheesing() {
         // Current loop indexes are stored for efficiency.
         const cursorLoopIndexes = osuBase.Utils.initializeArray(10, 0);
-        const acceptableRadius = this.calculator.objects[0].object.getRadius(osuBase.Modes.droid) * 2;
-        for (let i = 0; i <
-            Math.min(this.data.hitObjectData.length, this.calculator.objects.length); ++i) {
-            const diffObject = this.calculator.objects[i];
-            const { object } = diffObject;
-            if (diffObject.travelDistance === 0 ||
-                !(object instanceof osuBase.Slider)) {
+        const acceptableRadius = this.beatmap.hitObjects.objects[0].getRadius(osuBase.Modes.droid) * 2;
+        for (const difficultSlider of this.difficultyAttributes
+            .difficultSliders) {
+            if (difficultSlider.index >= this.data.hitObjectData.length) {
                 continue;
             }
+            const object = (this.beatmap.hitObjects.objects[difficultSlider.index]);
             const objectStartPosition = object.getStackedPosition(osuBase.Modes.droid);
-            const objectData = this.data.hitObjectData[i];
+            const objectData = this.data.hitObjectData[difficultSlider.index];
             // If a slider break occurs, we disregard the check for that slider.
             if (objectData.accuracy === Math.floor(this.hitWindow50) + 13) {
                 continue;
@@ -1938,7 +1759,7 @@ class SliderCheeseChecker {
                 }
             }
             if (isCheesed) {
-                this.cheesedObjectIndexes.push(i);
+                this.cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
             }
         }
     }
@@ -1946,32 +1767,16 @@ class SliderCheeseChecker {
      * Calculates the slider cheese penalty.
      */
     calculateSliderCheesePenalty() {
-        if (this.cheesedObjectIndexes.length === 0) {
-            return {
-                aimPenalty: 1,
-                flashlightPenalty: 1,
-                visualPenalty: 1,
-            };
-        }
-        let calculator;
-        if (this.calculator instanceof osuDifficultyCalculator.DroidDifficultyCalculator) {
-            calculator = new osuDifficultyCalculator.DroidDifficultyCalculator(this.calculator.beatmap);
-        }
-        else {
-            calculator = new osuRebalanceDifficultyCalculator.DroidDifficultyCalculator(this.calculator.beatmap);
-        }
-        Object.assign(calculator.attributes, this.calculator.attributes);
-        calculator.mods = this.calculator.mods;
-        calculator.stats = this.calculator.stats;
-        calculator.generateDifficultyHitObjects();
-        for (const index of this.cheesedObjectIndexes) {
-            calculator.objects[index].travelDistance = 0;
-        }
-        calculator.calculateAll();
+        const summedDifficultyRating = this.cheesedDifficultyRatings.reduce((a, v) => a + v, 0);
         return {
-            aimPenalty: this.calculator.aim / calculator.aim,
-            flashlightPenalty: this.calculator.flashlight / calculator.flashlight,
-            visualPenalty: this.calculator.visual / calculator.visual,
+            aimPenalty: 1 -
+                summedDifficultyRating * this.difficultyAttributes.sliderFactor,
+            flashlightPenalty: 1 -
+                summedDifficultyRating *
+                    this.difficultyAttributes.flashlightSliderFactor,
+            visualPenalty: 1 -
+                summedDifficultyRating *
+                    this.difficultyAttributes.visualSliderFactor,
         };
     }
 }
@@ -2008,6 +1813,10 @@ class ReplayAnalyzer {
      * The beatmap that is being analyzed. `DroidDifficultyCalculator` or `RebalanceDroidDifficultyCalculator` is required for three finger or two hand analyzing.
      */
     beatmap;
+    /**
+     * The difficulty attributes of the beatmap.
+     */
+    difficultyAttributes;
     /**
      * The results of the analyzer. `null` when initialized.
      */
@@ -2053,6 +1862,10 @@ class ReplayAnalyzer {
     constructor(values) {
         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;
+        }
     }
     /**
      * Analyzes a replay.
@@ -2094,10 +1907,10 @@ class ReplayAnalyzer {
      */
     decompress() {
         return new Promise((resolve, reject) => {
-            const stream$1 = new stream.Readable();
-            stream$1.push(this.originalODR);
-            stream$1.push(null);
-            stream$1
+            const stream = new node_stream.Readable();
+            stream.push(this.originalODR);
+            stream.push(null);
+            stream
                 .pipe(unzipper.Parse())
                 .on("entry", async (entry) => {
                 const fileName = entry.path;
@@ -2489,15 +2302,15 @@ class ReplayAnalyzer {
     /**
      * Checks if a play is using 3 fingers.
      *
-     * Requires `analyze()` to be called first and `map` to be defined as `DroidDifficultyCalculator`.
+     * Requires `analyze()` to be called first and `map` and `difficultyAttributes` to be defined.
      */
     checkFor3Finger() {
-        if (!(this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
-            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator) ||
-            !this.data) {
+        if (!this.beatmap || !this.data || !this.difficultyAttributes) {
             return;
         }
-        const threeFingerChecker = new ThreeFingerChecker(this.beatmap, this.data);
+        const threeFingerChecker = new ThreeFingerChecker(this.beatmap instanceof osuBase.Beatmap
+            ? this.beatmap
+            : this.beatmap.beatmap, this.data, this.difficultyAttributes);
         const result = threeFingerChecker.check();
         this.is3Finger = result.is3Finger;
         this.tapPenalty = result.penalty;
@@ -2523,15 +2336,15 @@ class ReplayAnalyzer {
     /**
      * Checks if a play has cheesed sliders.
      *
-     * Requires `analyze()` to be called first and `map` to be defined as `DroidDifficultyCalculator`.
+     * Requires `analyze()` to be called first and `map` and `difficultyAttributes` to be defined.
      */
     checkForSliderCheesing() {
-        if (!(this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
-            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator) ||
-            !this.data) {
+        if (!this.beatmap || !this.data || !this.difficultyAttributes) {
             return;
         }
-        const sliderCheeseChecker = new SliderCheeseChecker(this.beatmap, this.data);
+        const sliderCheeseChecker = new SliderCheeseChecker(this.beatmap instanceof osuBase.Beatmap
+            ? this.beatmap
+            : this.beatmap.beatmap, this.data, this.difficultyAttributes);
         this.sliderCheesePenalty = sliderCheeseChecker.check();
         this.hasBeenCheckedForSliderCheesing = true;
     }