@rian8337/osu-droid-replay-analyzer 4.0.0-beta.19 → 4.0.0-beta.20

package/dist/index.js

@@ -368,9 +368,6 @@ class RebalanceThreeFingerChecker {
             return { is3Finger: false, penalty: 1 };
         }
         this.getBeatmapSections();
-        if (this.downCursorInstances.filter((v) => v.length > 0).length <= 3) {
-            return { is3Finger: false, penalty: 1 };
-        }
         this.calculateNerfFactors();
         const finalPenalty = this.calculateFinalPenalty();
         return { is3Finger: finalPenalty > 1, penalty: finalPenalty };
@@ -834,25 +831,6 @@ class ThreeFingerChecker {
      * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
     constructor(beatmap, data, difficultyAttributes) {
-        /**
-         * 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.
-         */
-        this.cursorDistancingDistanceThreshold = 60;
-        /**
-         * The threshold for the amount of cursors that are assumed to be pressed
-         * by a single finger.
-         */
-        this.cursorDistancingCountThreshold = 10;
-        /**
-         * The threshold for the time difference of cursors that are assumed to be pressed
-         * by a single finger, in milliseconds.
-         */
-        this.cursorDistancingTimeThreshold = 1000;
         /**
          * The ratio threshold between non-3 finger cursors and 3-finger cursors.
          *
@@ -864,14 +842,6 @@ class ThreeFingerChecker {
          * Extended sections of the beatmap for drag detection.
          */
         this.beatmapSections = [];
-        /**
-         * This threshold is used to filter out accidental taps.
-         *
-         * Increasing this number makes the filtration more sensitive, however it
-         * will also increase the chance of 3-fingered plays getting out from
-         * being flagged.
-         */
-        this.accidentalTapThreshold = 400;
         /**
          * A reprocessed break points to match right on object time.
          *
@@ -899,8 +869,7 @@ class ThreeFingerChecker {
         }).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.
@@ -921,7 +890,7 @@ class ThreeFingerChecker {
      * nerf factor, taking beatmap difficulty into account.
      */
     check() {
-        if (this.strainNoteCount === 0) {
+        if (this.difficultyAttributes.possibleThreeFingeredSections.length === 0) {
             return { is3Finger: false, penalty: 1 };
         }
         this.getAccurateBreakPoints();
@@ -930,11 +899,6 @@ class ThreeFingerChecker {
             return { is3Finger: false, penalty: 1 };
         }
         this.getBeatmapSections();
-        this.detectDragPlay();
-        this.preventAccidentalTaps();
-        if (this.downCursorInstances.filter((v) => v.length > 0).length <= 3) {
-            return { is3Finger: false, penalty: 1 };
-        }
         this.calculateNerfFactors();
         const finalPenalty = this.calculateFinalPenalty();
         return { is3Finger: finalPenalty > 1, penalty: finalPenalty };
@@ -943,42 +907,31 @@ class ThreeFingerChecker {
      * Generates a new set of "accurate break points".
      *
      * This is done 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.
+     * end of the hitobject before it and do not end right at the first hitobject after it.
      */
     getAccurateBreakPoints() {
-        const { objects } = this.beatmap.hitObjects;
         const objectData = this.data.hitObjectData;
         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(this.isPrecise);
-            switch (objectData[beforeIndex].result) {
-                case exports.HitResult.great:
-                    beforeIndexHitWindowLength = this.hitWindow.hitWindowFor300(this.isPrecise);
-                    break;
-                case exports.HitResult.good:
-                    beforeIndexHitWindowLength = this.hitWindow.hitWindowFor100(this.isPrecise);
-                    break;
-                default:
-                    beforeIndexHitWindowLength = this.hitWindow.hitWindowFor50(this.isPrecise);
+            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);
+                }
             }
-            timeBefore += beforeIndexHitWindowLength;
             const afterIndex = beforeIndex + 1;
-            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(this.isPrecise);
-            switch (objectData[afterIndex].result) {
-                case exports.HitResult.great:
-                    afterIndexHitWindowLength = this.hitWindow.hitWindowFor300(this.isPrecise);
-                    break;
-                case exports.HitResult.good:
-                    afterIndexHitWindowLength = this.hitWindow.hitWindowFor100(this.isPrecise);
-                    break;
-                default:
-                    afterIndexHitWindowLength = this.hitWindow.hitWindowFor50(this.isPrecise);
+            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;
             }
-            timeAfter += afterIndexHitWindowLength;
             this.breakPointAccurateTimes.push(new osuBase.BreakPoint({
                 startTime: timeBefore,
                 endTime: timeAfter,
@@ -991,12 +944,11 @@ class ThreeFingerChecker {
      * This also filters cursors that are in break period or happen before start/after end of the beatmap.
      */
     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;
+        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) {
@@ -1025,16 +977,17 @@ class ThreeFingerChecker {
                     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 (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            const cursorInstance = this.data.cursorMovement[i];
+        for (const cursorInstance of this.data.cursorMovement) {
             const validOccurrences = [];
-            for (let j = 0; j < cursorInstance.occurrenceGroups.length; ++j) {
-                const group = cursorInstance.occurrenceGroups[j];
+            for (const group of cursorInstance.occurrenceGroups) {
                 if (group.startTime < firstObjectHitTime) {
                     continue;
                 }
@@ -1055,20 +1008,93 @@ class ThreeFingerChecker {
      * detect dragged sections and improve detection speed.
      */
     getBeatmapSections() {
+        const cursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
         for (const section of this.difficultyAttributes
             .possibleThreeFingeredSections) {
-            this.beatmapSections.push(Object.assign(Object.assign({}, section), { isDragged: false, dragFingerIndex: -1 }));
+            const dragFingerIndex = this.findDragIndex(section);
+            const objects = [];
+            for (let i = section.firstObjectIndex; i <= section.lastObjectIndex; ++i) {
+                objects.push(Object.assign({ object: this.hitObjects[i] }, this.getObjectPressIndex(this.hitObjects[i], this.data.hitObjectData[i], cursorLookupIndices, dragFingerIndex)));
+            }
+            this.beatmapSections.push(Object.assign(Object.assign({}, section), { dragFingerIndex: dragFingerIndex, objects: objects }));
         }
     }
     /**
-     * Checks whether or not each beatmap sections is dragged.
+     * 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.
      */
-    detectDragPlay() {
-        for (let i = 0; i < this.beatmapSections.length; ++i) {
-            const dragIndex = this.checkDrag(this.beatmapSections[i]);
-            this.beatmapSections[i].dragFingerIndex = dragIndex;
-            this.beatmapSections[i].isDragged = dragIndex !== -1;
+    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 !== null && nearestCursorInstanceIndex !== void 0 ? nearestCursorInstanceIndex : -1,
+            pressingCursorIndex: nearestCursorIndex !== null && nearestCursorIndex !== void 0 ? nearestCursorIndex : -1,
+        };
     }
     /**
      * Checks if a section is dragged and returns the index of the drag finger.
@@ -1077,11 +1103,11 @@ class ThreeFingerChecker {
      *
      * @param section The section to check.
      */
-    checkDrag(section) {
-        const { objects } = this.beatmap.hitObjects;
+    findDragIndex(section) {
+        var _a;
         const objectData = this.data.hitObjectData;
-        const firstObject = objects[section.firstObjectIndex];
-        const lastObject = objects[section.lastObjectIndex];
+        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) {
@@ -1095,7 +1121,7 @@ class ThreeFingerChecker {
                     firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
             }
         }
-        else {
+        else if (firstObject instanceof osuBase.Slider) {
             firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
         }
         let lastObjectMaxHitTime = lastObject.startTime;
@@ -1111,12 +1137,12 @@ class ThreeFingerChecker {
                     lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(this.isPrecise);
             }
         }
-        else {
-            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 cursorIndexes = [];
+        const cursorIndices = [];
         for (let i = 0; i < this.data.cursorMovement.length; ++i) {
             const c = this.data.cursorMovement[i];
             if (c.occurrenceGroups.length === 0) {
@@ -1133,21 +1159,12 @@ class ThreeFingerChecker {
                 0) {
                 continue;
             }
-            cursorIndexes.push(i);
+            cursorIndices.push(i);
         }
-        return this.findDragIndex(objects.slice(section.firstObjectIndex, section.lastObjectIndex + 1), objectData.slice(section.firstObjectIndex, section.lastObjectIndex + 1), cursorIndexes);
-    }
-    /**
-     * Finds the drag index of the section.
-     *
-     * @param sectionObjects The objects in the section.
-     * @param sectionReplayObjectData The hitobject data of all objects in the section.
-     * @param cursorIndexes The indexes of the cursor instance that has at least an occurrence in the section.
-     */
-    findDragIndex(sectionObjects, sectionReplayObjectData, cursorIndexes) {
-        var _a;
+        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 && cursorIndexes.every((v) => v !== -1); ++i) {
+        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 ||
@@ -1162,201 +1179,98 @@ class ThreeFingerChecker {
             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) {
+            for (let j = 0; j < cursorIndices.length; ++j) {
+                if (cursorIndices[j] === -1) {
                     continue;
                 }
-                const cursorData = this.data.cursorMovement[cursorIndexes[j]];
+                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];
-                    if (prevCursor.time < object.startTime - hitWindow50) {
-                        continue;
-                    }
-                    if (prevCursor.time > object.startTime + hitWindow50) {
-                        break;
-                    }
-                    let isInObject = false;
-                    switch (cursor.id) {
-                        case exports.MovementType.up:
-                            isInObject =
-                                prevCursor.position.getDistance(objectPosition) <= object.radius;
-                            break;
-                        case exports.MovementType.move:
-                            // Interpolate movement.
-                            for (let mSecPassed = prevCursor.time; !isInObject &&
-                                mSecPassed <=
-                                    Math.min(cursor.time, object.startTime + hitWindow50); ++mSecPassed) {
-                                const t = (mSecPassed - prevCursor.time) /
+                    // 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;
                             }
-                    }
-                    if (!isInObject) {
-                        cursorIndexes[j] = -1;
+                        }
+                        break;
                     }
                 }
+                if (!isInObject) {
+                    cursorIndices[j] = -1;
+                }
             }
         }
-        return (_a = cursorIndexes.find((v) => v !== -1)) !== null && _a !== void 0 ? _a : -1;
-    }
-    /**
-     * Attempts to prevent accidental taps from being flagged.
-     *
-     * This detection will filter cursors that don't hit
-     * any object in beatmap sections, thus eliminating any
-     * unnecessary taps.
-     */
-    preventAccidentalTaps() {
-        let filledCursorAmount = this.downCursorInstances.filter((v) => v.length > 0).length;
-        if (filledCursorAmount <= 3) {
-            return;
-        }
-        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) {
-                break;
-            }
-            const cursorInstances = this.downCursorInstances[i];
-            // Use an estimation for accidental tap threshold.
-            if (cursorInstances.length <=
-                Math.ceil(objects.length / this.accidentalTapThreshold) &&
-                cursorInstances.length / totalCursorAmount <
-                    this.threeFingerRatioThreshold * 2) {
-                --filledCursorAmount;
-                cursorInstances.length = 0;
-            }
-            this.downCursorInstances[i] = cursorInstances;
-        }
+        return (_a = cursorIndices.find((v) => v !== -1)) !== null && _a !== void 0 ? _a : -1;
     }
     /**
      * Creates nerf factors by scanning through objects.
-     *
-     * This check will ignore all objects with speed strain below `strainThreshold`.
      */
     calculateNerfFactors() {
-        const { objects } = this.beatmap.hitObjects;
-        const objectData = this.data.hitObjectData;
-        // 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].startTime +
-                (objectData[beatmapSection.firstObjectIndex].result !==
-                    exports.HitResult.miss
-                    ? objectData[beatmapSection.firstObjectIndex].accuracy
-                    : -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(this.isPrecise));
-            const cursorAmounts = [];
-            const sectionCursors = [];
-            for (let i = 0; i < this.downCursorInstances.length; ++i) {
-                // Do not include drag cursor instance.
-                if (i === dragIndex) {
+            const cursorCounts = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+            for (const object of beatmapSection.objects) {
+                if (object.pressingCursorIndex === -1 ||
+                    object.pressingCursorInstanceIndex ===
+                        beatmapSection.dragFingerIndex) {
                     continue;
                 }
-                const cursors = this.downCursorInstances[i];
-                let amount = 0;
-                for (let j = 0; j < cursors.length; ++j) {
-                    if (cursors[j].time >= startTime &&
-                        cursors[j].time <= endTime) {
-                        ++amount;
-                        sectionCursors.push(cursors[j]);
-                    }
-                }
-                cursorAmounts.push(amount);
+                ++cursorCounts[object.pressingCursorInstanceIndex];
+            }
+            if (beatmapSection.dragFingerIndex !== -1) {
+                // Remove the drag index to prevent it from being picked up into the detection.
+                cursorCounts.splice(beatmapSection.dragFingerIndex, 1);
             }
-            sectionCursors.sort((a, b) => a.time - b.time);
             // 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 = dragIndex !== -1 ? 2 : 3;
+            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
+            const threeFingerRatio = cursorCounts
                 .slice(fingerSplitIndex)
                 .reduce((acc, value) => acc + value, 0) /
-                cursorAmounts
+                Math.max(cursorCounts
                     .slice(0, fingerSplitIndex)
+                    .reduce((acc, value) => acc + value, 0), 1);
+            if (threeFingerRatio > this.threeFingerRatioThreshold) {
+                const threeFingeredObjectCount = cursorCounts
+                    .slice(fingerSplitIndex)
                     .reduce((acc, value) => acc + value, 0);
-            const similarPresses = [];
-            for (const sectionCursor of sectionCursors) {
-                const pressIndex = similarPresses.findIndex((v) => v.lastPosition.getDistance(sectionCursor.position) <=
-                    this.cursorDistancingDistanceThreshold);
-                if (pressIndex !== -1) {
-                    if (sectionCursor.time -
-                        similarPresses[pressIndex].lastTime >=
-                        this.cursorDistancingTimeThreshold) {
-                        similarPresses.splice(pressIndex, 1);
-                        similarPresses.push({
-                            lastPosition: sectionCursor.position,
-                            count: 1,
-                            lastTime: sectionCursor.time,
-                        });
-                        continue;
-                    }
-                    similarPresses[pressIndex].lastPosition =
-                        sectionCursor.position;
-                    similarPresses[pressIndex].lastTime = sectionCursor.time;
-                    ++similarPresses[pressIndex].count;
-                }
-                else {
-                    similarPresses.push({
-                        lastPosition: sectionCursor.position,
-                        count: 1,
-                        lastTime: sectionCursor.time,
-                    });
-                }
-            }
-            // Sort by highest count; assume the order is 3rd, 4th, 5th, ... finger
-            const validPresses = similarPresses
-                .filter((v) => v.count >= this.cursorDistancingCountThreshold)
-                .sort((a, b) => b.count - a.count)
-                .slice(2);
-            // Ignore cursor presses that are only 1 for now since they are very likely to be accidental
-            if ((threeFingerRatio > this.threeFingerRatioThreshold &&
-                cursorAmounts.filter((v) => v > 1).length >
-                    fingerSplitIndex) ||
-                validPresses.length > 0) {
-                // Strain factor
-                const objectCount = beatmapSection.lastObjectIndex -
+                const sectionObjectCount = beatmapSection.lastObjectIndex -
                     beatmapSection.firstObjectIndex +
                     1;
+                const threeFingeredObjectRatio = threeFingeredObjectCount / sectionObjectCount;
                 // We can ignore the first 3 (2 for drag) filled cursor instances
                 // since they are guaranteed not 3 finger.
-                const threeFingerCursorAmounts = cursorAmounts
+                const threeFingerCursorCounts = cursorCounts
                     .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(validPresses.reduce((acc, value, index) => acc +
-                        Math.pow(((index + 1) *
-                            (value.count /
-                                (this
-                                    .cursorDistancingCountThreshold *
-                                    2)) *
-                            objectCount) /
-                            this.strainNoteCount, 0.2), 1), 0.2);
+                const fingerFactor = threeFingerCursorCounts.reduce((acc, count, index) => acc +
+                    Math.pow((index + 1) * count * threeFingeredObjectRatio, 0.9), 1);
                 // Length factor applies more penalty if there are more 3-fingered object.
-                const lengthFactor = 1 + Math.pow(objectCount / this.strainNoteCount, 1.2);
+                const lengthFactor = 1 + Math.pow(threeFingeredObjectRatio, 1.2);
                 this.nerfFactors.push({
-                    strainFactor: Math.max(1, beatmapSection.sumStrain),
-                    fingerFactor,
-                    lengthFactor,
+                    strainFactor: beatmapSection.sumStrain * threeFingeredObjectRatio,
+                    fingerFactor: fingerFactor,
+                    lengthFactor: lengthFactor,
                 });
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-droid-replay-analyzer",
-    "version": "4.0.0-beta.19",
+    "version": "4.0.0-beta.20",
     "description": "A replay analyzer for analyzing osu!droid replay files.",
     "keywords": [
         "osu",
@@ -35,8 +35,8 @@
     },
     "dependencies": {
         "@rian8337/osu-base": "^4.0.0-beta.19",
-        "@rian8337/osu-difficulty-calculator": "^4.0.0-beta.19",
-        "@rian8337/osu-rebalance-difficulty-calculator": "^4.0.0-beta.19",
+        "@rian8337/osu-difficulty-calculator": "^4.0.0-beta.20",
+        "@rian8337/osu-rebalance-difficulty-calculator": "^4.0.0-beta.20",
         "java-deserialization": "^0.1.0",
         "unzipper": "^0.10.11"
     },
@@ -46,5 +46,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "45f7c976ba683027dc3a4d29de8bf289aadf7707"
+    "gitHead": "8e6d7449a4a949f0158f10b9130378e7368bd8aa"
 }

package/typings/index.d.ts

@@ -861,28 +861,11 @@ declare class ThreeFingerChecker {
      */
     readonly difficultyAttributes: ExtendedDroidDifficultyAttributes$1;
     /**
-     * The distance threshold between cursors to assume that two cursors are
-     * actually pressed with 1 finger in osu!pixels.
+     * The hitobjects to be analyzed.
      *
-     * 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.
-     */
-    private readonly cursorDistancingDistanceThreshold;
-    /**
-     * The threshold for the amount of cursors that are assumed to be pressed
-     * by a single finger.
-     */
-    private readonly cursorDistancingCountThreshold;
-    /**
-     * The threshold for the time difference of cursors that are assumed to be pressed
-     * by a single finger, in milliseconds.
-     */
-    private readonly cursorDistancingTimeThreshold;
-    /**
-     * The amount of notes that has a tap strain exceeding `strainThreshold`.
+     * This is being maintained separately due to possible change in object scale.
      */
-    private readonly strainNoteCount;
+    private readonly hitObjects;
     /**
      * The ratio threshold between non-3 finger cursors and 3-finger cursors.
      *
@@ -894,14 +877,6 @@ declare class ThreeFingerChecker {
      * Extended sections of the beatmap for drag detection.
      */
     private readonly beatmapSections;
-    /**
-     * This threshold is used to filter out accidental taps.
-     *
-     * Increasing this number makes the filtration more sensitive, however it
-     * will also increase the chance of 3-fingered plays getting out from
-     * being flagged.
-     */
-    private readonly accidentalTapThreshold;
     /**
      * The hit window of this beatmap. Keep in mind that speed-changing mods do not change hit window length in game logic.
      */
@@ -954,7 +929,7 @@ declare class ThreeFingerChecker {
      * Generates a new set of "accurate break points".
      *
      * This is done 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.
+     * end of the hitobject before it and do not end right at the first hitobject after it.
      */
     private getAccurateBreakPoints;
     /**
@@ -969,9 +944,15 @@ declare class ThreeFingerChecker {
      */
     private getBeatmapSections;
     /**
-     * Checks whether or not each beatmap sections is dragged.
+     * 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.
      */
-    private detectDragPlay;
+    private getObjectPressIndex;
     /**
      * Checks if a section is dragged and returns the index of the drag finger.
      *
@@ -979,27 +960,9 @@ declare class ThreeFingerChecker {
      *
      * @param section The section to check.
      */
-    private checkDrag;
-    /**
-     * Finds the drag index of the section.
-     *
-     * @param sectionObjects The objects in the section.
-     * @param sectionReplayObjectData The hitobject data of all objects in the section.
-     * @param cursorIndexes The indexes of the cursor instance that has at least an occurrence in the section.
-     */
     private findDragIndex;
-    /**
-     * Attempts to prevent accidental taps from being flagged.
-     *
-     * This detection will filter cursors that don't hit
-     * any object in beatmap sections, thus eliminating any
-     * unnecessary taps.
-     */
-    private preventAccidentalTaps;
     /**
      * Creates nerf factors by scanning through objects.
-     *
-     * This check will ignore all objects with speed strain below `strainThreshold`.
      */
     private calculateNerfFactors;
     /**