@rian8337/osu-droid-replay-analyzer 1.4.12-alpha.4 → 1.4.12-alpha.7

package/dist/analysis/ThreeFingerChecker.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThreeFingerChecker = void 0;
 const osu_base_1 = require("@rian8337/osu-base");
-const __1 = require("..");
+const hitResult_1 = require("../constants/hitResult");
+const movementType_1 = require("../constants/movementType");
 const CursorData_1 = require("../data/CursorData");
 const BeatmapSectionGenerator_1 = require("./BeatmapSectionGenerator");
 const ThreeFingerBeatmapSection_1 = require("./data/ThreeFingerBeatmapSection");
@@ -15,25 +16,6 @@ class ThreeFingerChecker {
      * @param data The data of the replay.
      */
     constructor(map, data) {
-        /**
-         * 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.
          *
@@ -49,7 +31,7 @@ class ThreeFingerChecker {
          * Note that this value does not account for the speed multiplier of
          * the play, similar to the way replay object data is stored.
          */
-        this.maxSectionDeltaTime = 2000;
+        this.maxSectionDeltaTime = 1000;
         /**
          * The minimum object count required to make a beatmap section.
          *
@@ -60,14 +42,6 @@ class ThreeFingerChecker {
          * The sections of the beatmap that was cut based on `maxSectionDeltaTime` and `minSectionObjectCount`.
          */
         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.
          *
@@ -79,6 +53,11 @@ class ThreeFingerChecker {
          * A cursor data array that only contains `movementType.DOWN` movement ID occurrences.
          */
         this.downCursorInstances = [];
+        /**
+         * The indexes of cursors that presses objects that fall under {@link beatmapSections beatmap sections},
+         * mapped by each object's unadjusted start time.
+         */
+        this.objectCursorIndexes = new Map();
         /**
          * Nerf factors from all sections that were three-fingered.
          */
@@ -121,9 +100,9 @@ class ThreeFingerChecker {
             return { is3Finger: false, penalty: 1 };
         }
         this.getBeatmapSections();
-        this.detectDragPlay();
+        this.assignFingerIndexes();
         this.getDetailedBeatmapSections();
-        this.preventAccidentalTaps();
+        this.assignCursorIndexesToObjects();
         if (this.downCursorInstances.filter((v) => v.size > 0).length <= 3) {
             return { is3Finger: false, penalty: 1 };
         }
@@ -147,11 +126,11 @@ class ThreeFingerChecker {
             // For sliders and spinners, automatically set hit window length to be as lenient as possible.
             let beforeIndexHitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
             switch (objectData[beforeIndex].result) {
-                case __1.hitResult.RESULT_300:
+                case hitResult_1.hitResult.RESULT_300:
                     beforeIndexHitWindowLength =
                         this.hitWindow.hitWindowFor300(isPrecise);
                     break;
-                case __1.hitResult.RESULT_100:
+                case hitResult_1.hitResult.RESULT_100:
                     beforeIndexHitWindowLength =
                         this.hitWindow.hitWindowFor100(isPrecise);
                     break;
@@ -165,11 +144,11 @@ class ThreeFingerChecker {
             // For sliders and spinners, automatically set hit window length to be as lenient as possible.
             let afterIndexHitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
             switch (objectData[afterIndex].result) {
-                case __1.hitResult.RESULT_300:
+                case hitResult_1.hitResult.RESULT_300:
                     afterIndexHitWindowLength =
                         this.hitWindow.hitWindowFor300(isPrecise);
                     break;
-                case __1.hitResult.RESULT_100:
+                case hitResult_1.hitResult.RESULT_100:
                     afterIndexHitWindowLength =
                         this.hitWindow.hitWindowFor100(isPrecise);
                     break;
@@ -199,11 +178,11 @@ class ThreeFingerChecker {
         let firstObjectHitWindow = this.hitWindow.hitWindowFor50(isPrecise);
         if (objects[0].object instanceof osu_base_1.Circle) {
             switch (firstObjectResult) {
-                case __1.hitResult.RESULT_300:
+                case hitResult_1.hitResult.RESULT_300:
                     firstObjectHitWindow =
                         this.hitWindow.hitWindowFor300(isPrecise);
                     break;
-                case __1.hitResult.RESULT_100:
+                case hitResult_1.hitResult.RESULT_100:
                     firstObjectHitWindow =
                         this.hitWindow.hitWindowFor100(isPrecise);
                     break;
@@ -216,11 +195,11 @@ class ThreeFingerChecker {
         let lastObjectHitWindow = this.hitWindow.hitWindowFor50(isPrecise);
         if (objects.at(-1).object instanceof osu_base_1.Circle) {
             switch (lastObjectResult) {
-                case __1.hitResult.RESULT_300:
+                case hitResult_1.hitResult.RESULT_300:
                     lastObjectHitWindow =
                         this.hitWindow.hitWindowFor300(isPrecise);
                     break;
-                case __1.hitResult.RESULT_100:
+                case hitResult_1.hitResult.RESULT_100:
                     lastObjectHitWindow =
                         this.hitWindow.hitWindowFor100(isPrecise);
                     break;
@@ -244,7 +223,7 @@ class ThreeFingerChecker {
                 id: [],
             });
             for (let j = 0; j < cursorInstance.size; ++j) {
-                if (cursorInstance.id[j] !== __1.movementType.DOWN) {
+                if (cursorInstance.id[j] !== movementType_1.movementType.DOWN) {
                     continue;
                 }
                 const time = cursorInstance.time[j];
@@ -273,162 +252,113 @@ class ThreeFingerChecker {
             this.beatmapSections.push(new ThreeFingerBeatmapSection_1.ThreeFingerBeatmapSection({
                 firstObjectIndex: beatmapSection.firstObjectIndex,
                 lastObjectIndex: beatmapSection.lastObjectIndex,
-                isDragged: false,
-                dragFingerIndex: -1,
+                mainFingerIndex: -1,
             }));
         }
     }
     /**
-     * Checks whether or not each beatmap sections is dragged.
+     * Assigns main finger indexes for each beatmap section.
      */
-    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;
+    assignFingerIndexes() {
+        for (const section of this.beatmapSections) {
+            let currentIndex = this.getMainFingerIndex(section);
+            if (currentIndex === null) {
+                const firstObject = this.map.objects[section.firstObjectIndex];
+                const firstObjectData = this.data.hitObjectData[section.firstObjectIndex];
+                const lastObject = this.map.objects[section.lastObjectIndex];
+                const lastObjectData = this.data.hitObjectData[section.lastObjectIndex];
+                const startTime = firstObject.object.startTime + firstObjectData.accuracy;
+                const endTime = lastObject.object.endTime + lastObjectData.accuracy;
+                // Get the cursor instance index in the section that has the most movementType.MOVE instance.
+                const moveInstanceAmounts = [];
+                for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+                    let amount = 0;
+                    const c = this.data.cursorMovement[i];
+                    for (let j = 0; j < c.size; ++j) {
+                        if (c.time[j] < startTime) {
+                            continue;
+                        }
+                        if (c.time[j] > endTime) {
+                            break;
+                        }
+                        if (c.id[j] === movementType_1.movementType.MOVE) {
+                            ++amount;
+                        }
+                    }
+                    moveInstanceAmounts.push(amount);
+                }
+                currentIndex = moveInstanceAmounts.indexOf(Math.max(...moveInstanceAmounts));
+            }
+            section.mainFingerIndex = currentIndex;
         }
     }
     /**
-     * Checks if a section is dragged and returns the index of the drag finger.
-     *
-     * If the section is not dragged, -1 will be returned.
+     * Gets the main finger index of a beatmap section.
      *
-     * @param section The section to check.
+     * @param section The beatmap section.
      */
-    checkDrag(section) {
-        const objects = this.map.objects;
-        const objectData = this.data.hitObjectData;
-        const isPrecise = this.map.mods.some((m) => m instanceof osu_base_1.ModPrecise);
-        const firstObject = objects[section.firstObjectIndex];
-        const lastObject = objects[section.lastObjectIndex];
-        let firstObjectMinHitTime = firstObject.object.startTime;
-        if (firstObject.object instanceof osu_base_1.Circle) {
-            switch (objectData[section.firstObjectIndex].result) {
-                case __1.hitResult.RESULT_300:
-                    firstObjectMinHitTime -=
-                        this.hitWindow.hitWindowFor300(isPrecise);
-                    break;
-                case __1.hitResult.RESULT_100:
-                    firstObjectMinHitTime -=
-                        this.hitWindow.hitWindowFor100(isPrecise);
-                    break;
-                default:
-                    firstObjectMinHitTime -=
-                        this.hitWindow.hitWindowFor50(isPrecise);
-            }
-        }
-        else {
-            firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(isPrecise);
-        }
-        let lastObjectMaxHitTime = lastObject.object.startTime;
-        if (lastObject.object instanceof osu_base_1.Circle) {
-            switch (objectData[section.lastObjectIndex].result) {
-                case __1.hitResult.RESULT_300:
-                    lastObjectMaxHitTime +=
-                        this.hitWindow.hitWindowFor300(isPrecise);
-                    break;
-                case __1.hitResult.RESULT_100:
-                    lastObjectMaxHitTime +=
-                        this.hitWindow.hitWindowFor100(isPrecise);
-                    break;
-                default:
-                    lastObjectMaxHitTime +=
-                        this.hitWindow.hitWindowFor50(isPrecise);
-            }
-        }
-        else {
-            lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(isPrecise);
-        }
-        // Since there may be more than 1 cursor instance index,
-        // we check which cursor instance follows hitobjects all over.
-        const cursorIndexes = [];
+    getMainFingerIndex(section) {
+        const validCursorIndexes = new Set();
+        const timeDiscrepancy = 10;
         for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            const c = this.data.cursorMovement[i];
-            if (c.size === 0) {
-                continue;
+            if (this.data.cursorMovement[i].size > 0) {
+                validCursorIndexes.add(i);
             }
-            // Do not include cursors that don't have an occurence in this section
-            // this speeds up checking process.
-            if (c.time.filter((v) => v >= firstObjectMinHitTime && v <= lastObjectMaxHitTime).length === 0) {
-                continue;
-            }
-            // If this cursor instance doesn't move, it's not the cursor instance we want.
-            if (c.id.filter((v) => v === __1.movementType.MOVE).length === 0) {
-                continue;
-            }
-            cursorIndexes.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) {
-        let objectIndex = sectionObjects.findIndex((v, i) => !(v.object instanceof osu_base_1.Spinner) &&
-            sectionReplayObjectData[i].result !== __1.hitResult.RESULT_0);
-        if (objectIndex === -1) {
-            return -1;
-        }
-        while (cursorIndexes.length > 0) {
-            if (objectIndex === sectionObjects.length) {
+        for (let i = section.firstObjectIndex; i <= section.lastObjectIndex; ++i) {
+            if (validCursorIndexes.size === 0) {
                 break;
             }
-            const o = sectionObjects[objectIndex];
-            const s = sectionReplayObjectData[objectIndex];
-            ++objectIndex;
-            if (s.result === __1.hitResult.RESULT_0) {
+            const object = this.map.objects[i];
+            if (object.object instanceof osu_base_1.Spinner) {
                 continue;
             }
-            // Get the cursor instance that is closest to the object's hit time.
-            for (let j = 0; j < cursorIndexes.length; ++j) {
-                const c = this.data.cursorMovement[cursorIndexes[j]];
-                // Cursor instances aren't always recorded at all times,
-                // therefore the game emulates the movement between
-                // movementType.MOVE cursors.
-                const hitTime = o.object.startTime + s.accuracy;
-                const nextHitIndex = c.time.findIndex((v) => v >= hitTime);
-                const hitIndex = nextHitIndex - 1;
-                if (hitIndex <= -1) {
-                    cursorIndexes[j] = -1;
-                    continue;
-                }
-                if (c.id[hitIndex] === __1.movementType.UP) {
-                    cursorIndexes[j] = -1;
+            const objectData = this.data.hitObjectData[i];
+            const hitTime = object.startTime + objectData.accuracy;
+            for (let j = 0; j < this.data.cursorMovement.length; ++j) {
+                if (!validCursorIndexes.has(j)) {
                     continue;
                 }
-                const cursorPosition = new osu_base_1.Vector2(c.x[hitIndex], c.y[hitIndex]);
-                let isInObject = false;
-                if (c.id[nextHitIndex] === __1.movementType.MOVE ||
-                    c.id[hitIndex] === __1.movementType.MOVE) {
-                    // Try to interpolate movement between two movementType.MOVE cursor every 1ms.
-                    // This minimizes rounding error.
-                    for (let mSecPassed = c.time[hitIndex]; mSecPassed <= c.time[nextHitIndex]; ++mSecPassed) {
-                        const t = (mSecPassed - c.time[nextHitIndex]) /
-                            (c.time[hitIndex] - c.time[nextHitIndex]);
-                        cursorPosition.x = osu_base_1.Interpolation.lerp(c.x[hitIndex], c.x[nextHitIndex], t);
-                        cursorPosition.y = osu_base_1.Interpolation.lerp(c.y[hitIndex], c.y[nextHitIndex], t);
-                        if (o.object.stackedPosition.getDistance(cursorPosition) <= o.object.radius) {
-                            isInObject = true;
-                            break;
+                const c = this.data.cursorMovement[j];
+                for (let k = 0; k < c.size; ++k) {
+                    if (c.time[k] < hitTime - timeDiscrepancy ||
+                        c.id[k] === movementType_1.movementType.UP) {
+                        continue;
+                    }
+                    if (c.time[k] > hitTime + timeDiscrepancy) {
+                        break;
+                    }
+                    // Calculate the initial cursor position assuming it's a DOWN movement type.
+                    const cursorPosition = new osu_base_1.Vector2(c.x[k], c.y[k]);
+                    let isInObject = false;
+                    // But if the next cursor is a move instance, then we extend through
+                    // time between both cursors and interpolate cursor position.
+                    if (c.id[k + 1] === movementType_1.movementType.MOVE) {
+                        // Loop every 1ms to increase accuracy and minimalize error.
+                        for (let mSecPassed = c.time[k]; mSecPassed <= c.time[k + 1]; ++mSecPassed) {
+                            const t = (mSecPassed - c.time[k + 1]) /
+                                (c.time[k] - c.time[k + 1]);
+                            cursorPosition.x = osu_base_1.Interpolation.lerp(c.x[k], c.x[k + 1], t);
+                            cursorPosition.y = osu_base_1.Interpolation.lerp(c.y[k], c.y[k + 1], t);
+                            if (object.object.stackedPosition.getDistance(cursorPosition) <= object.object.radius) {
+                                isInObject = true;
+                                break;
+                            }
                         }
                     }
-                }
-                else {
-                    isInObject =
-                        o.object.stackedPosition.getDistance(cursorPosition) <=
-                            o.object.radius;
-                }
-                if (!isInObject) {
-                    cursorIndexes[j] = -1;
+                    else {
+                        isInObject =
+                            object.object.stackedPosition.getDistance(cursorPosition) <= object.object.radius;
+                    }
+                    if (!isInObject) {
+                        validCursorIndexes.delete(j);
+                        break;
+                    }
                 }
             }
-            cursorIndexes = cursorIndexes.filter((v) => v !== -1);
         }
-        return cursorIndexes.shift() ?? -1;
+        const [first] = validCursorIndexes;
+        return first ?? null;
     }
     /**
      * Redivides the beatmap into sections.
@@ -457,18 +387,15 @@ class ThreeFingerChecker {
                     newBeatmapSections.push({
                         firstObjectIndex: newFirstObjectIndex,
                         lastObjectIndex: i,
-                        isDragged: beatmapSection.isDragged,
-                        dragFingerIndex: beatmapSection.dragFingerIndex,
+                        mainFingerIndex: beatmapSection.mainFingerIndex,
                     });
                 }
             }
             // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
             if (inSpeedSection) {
                 newBeatmapSections.push({
+                    ...beatmapSection,
                     firstObjectIndex: newFirstObjectIndex,
-                    lastObjectIndex: beatmapSection.lastObjectIndex,
-                    isDragged: beatmapSection.isDragged,
-                    dragFingerIndex: beatmapSection.dragFingerIndex,
                 });
             }
         }
@@ -476,41 +403,57 @@ class ThreeFingerChecker {
         this.beatmapSections.push(...newBeatmapSections);
     }
     /**
-     * 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.
+     * Assigns cursor indexes for each object that is included in {@link beatmapSections beatmap sections}.
      */
-    preventAccidentalTaps() {
-        let filledCursorAmount = this.downCursorInstances.filter((v) => v.size > 0).length;
-        if (filledCursorAmount <= 3) {
-            return;
-        }
-        const objects = this.map.objects;
-        const totalCursorAmount = this.downCursorInstances.reduce((acc, value) => acc + value.size, 0);
-        for (let i = 0; i < this.downCursorInstances.length; ++i) {
-            if (filledCursorAmount <= 3) {
-                break;
-            }
-            const cursorInstance = this.downCursorInstances[i];
-            // Use an estimation for accidental tap threshold.
-            if (cursorInstance.size <=
-                Math.ceil(objects.length / this.accidentalTapThreshold) &&
-                cursorInstance.size / totalCursorAmount <
-                    this.threeFingerRatioThreshold * 2) {
-                --filledCursorAmount;
-                for (const property in cursorInstance) {
-                    const prop = property;
-                    if (Array.isArray(cursorInstance[prop])) {
-                        cursorInstance[prop].length = 0;
+    assignCursorIndexesToObjects() {
+        const isPrecise = this.map.mods.some((m) => m instanceof osu_base_1.ModPrecise);
+        for (const section of this.beatmapSections) {
+            for (let i = section.firstObjectIndex; i <= section.lastObjectIndex; ++i) {
+                const object = this.map.objects[i];
+                const objectData = this.data.hitObjectData[i];
+                if (object.object instanceof osu_base_1.Spinner ||
+                    objectData.result === hitResult_1.hitResult.RESULT_0) {
+                    this.objectCursorIndexes.set(object.object.startTime, section.mainFingerIndex);
+                    continue;
+                }
+                let hitWindowLeniency = this.hitWindow.hitWindowFor50(isPrecise);
+                // For sliders, automatically set hit window length to be as lenient as possible.
+                if (object.object instanceof osu_base_1.Circle) {
+                    switch (objectData.result) {
+                        case hitResult_1.hitResult.RESULT_300:
+                            hitWindowLeniency =
+                                this.hitWindow.hitWindowFor300(isPrecise);
+                            break;
+                        case hitResult_1.hitResult.RESULT_100:
+                            hitWindowLeniency =
+                                this.hitWindow.hitWindowFor100(isPrecise);
+                            break;
                     }
-                    else {
-                        cursorInstance[prop] = 0;
+                }
+                const hitTime = object.object.startTime + objectData.accuracy;
+                // We only care about the object timing; position doesn't matter.
+                let smallestIndex = section.mainFingerIndex;
+                let smallestDeltaTime = Number.POSITIVE_INFINITY;
+                for (let j = 0; j < this.downCursorInstances.length; ++j) {
+                    const c = this.downCursorInstances[j];
+                    for (let k = 0; k < c.size; ++k) {
+                        if (c.time[k] <
+                            object.object.startTime - hitWindowLeniency) {
+                            continue;
+                        }
+                        const deltaTime = Math.abs(hitTime - c.time[k]);
+                        // Don't continue if it's past object hit time.
+                        if (c.time[k] > hitTime) {
+                            break;
+                        }
+                        if (smallestDeltaTime > deltaTime) {
+                            smallestDeltaTime = deltaTime;
+                            smallestIndex = j;
+                        }
                     }
                 }
+                this.objectCursorIndexes.set(object.object.startTime, smallestIndex);
             }
-            this.downCursorInstances[i] = cursorInstance;
         }
     }
     /**
@@ -520,132 +463,53 @@ class ThreeFingerChecker {
      */
     calculateNerfFactors() {
         const objects = this.map.objects;
-        const objectData = this.data.hitObjectData;
-        const isPrecise = this.data.convertedMods.some((m) => m instanceof osu_base_1.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 +
-                (objectData[beatmapSection.firstObjectIndex].result !==
-                    __1.hitResult.RESULT_0
-                    ? objectData[beatmapSection.firstObjectIndex].accuracy
-                    : -this.hitWindow.hitWindowFor50(isPrecise));
-            const endTime = objects[beatmapSection.lastObjectIndex].object.endTime +
-                (objectData[beatmapSection.lastObjectIndex].result !==
-                    __1.hitResult.RESULT_0
-                    ? objectData[beatmapSection.lastObjectIndex].accuracy
-                    : this.hitWindow.hitWindowFor50(isPrecise));
-            // Filter cursor instances during section.
-            this.downCursorInstances.forEach((c) => {
-                const i = c.time.findIndex((t) => t >= startTime);
-                if (i !== -1) {
-                    c.size -= i;
-                    c.time.splice(0, i);
-                    c.x.splice(0, i);
-                    c.y.splice(0, i);
-                    c.id.splice(0, i);
-                }
-            });
-            const cursorAmounts = [];
-            const cursorVectorTimes = [];
-            for (let i = 0; i < this.downCursorInstances.length; ++i) {
-                // Do not include drag cursor instance.
-                if (i === dragIndex) {
+            const cursorAmounts = osu_base_1.Utils.initializeArray(this.downCursorInstances.length, 0);
+            for (let i = beatmapSection.firstObjectIndex; i <= beatmapSection.lastObjectIndex; ++i) {
+                ++cursorAmounts[this.objectCursorIndexes.get(objects[i].object.startTime)];
+            }
+            let validCursorPressCount = 0;
+            let invalidCursorPressCount = 0;
+            const validIndexes = [beatmapSection.mainFingerIndex];
+            for (let i = 0; i < cursorAmounts.length; ++i) {
+                // Ignore the main cursor index.
+                if (i === beatmapSection.mainFingerIndex) {
                     continue;
                 }
-                const cursorData = this.downCursorInstances[i];
-                let amount = 0;
-                for (let j = 0; j < cursorData.size; ++j) {
-                    if (cursorData.time[j] >= startTime &&
-                        cursorData.time[j] <= endTime) {
-                        ++amount;
-                        cursorVectorTimes.push({
-                            vector: new osu_base_1.Vector2(cursorData.x[j], cursorData.y[j]),
-                            time: cursorData.time[j],
-                        });
-                    }
-                }
-                cursorAmounts.push(amount);
-            }
-            // 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;
-            // 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) /
-                cursorAmounts
-                    .slice(0, fingerSplitIndex)
-                    .reduce((acc, value) => acc + value, 0);
-            const similarPresses = [];
-            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) {
-                        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;
+                // Add 2f cursor presses to valid cursor count and the rest to invalid cursor count.
+                if (validIndexes.length <= 2) {
+                    validCursorPressCount += cursorAmounts[i];
                 }
                 else {
-                    similarPresses.push({
-                        vector: cursorVectorTime.vector,
-                        count: 1,
-                        lastTime: cursorVectorTime.time,
-                    });
+                    invalidCursorPressCount += cursorAmounts[i];
                 }
+                validIndexes.push(i);
             }
-            // Sort by highest count; assume the order is 3rd, 4th, 5th, ... finger
-            const validPresses = similarPresses
-                .filter((v) => v.count >= this.cursorDistancingCountThreshold)
-                .sort((a, b) => {
-                return 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 > 3) ||
-                validPresses.length > 0) {
+            if (invalidCursorPressCount / validCursorPressCount >
+                this.threeFingerRatioThreshold &&
+                cursorAmounts.filter((v) => v > 1).length > 3) {
                 // Strain factor
                 const objectCount = beatmapSection.lastObjectIndex -
                     beatmapSection.firstObjectIndex +
                     1;
                 const strainFactor = Math.pow(objects
-                    .slice(beatmapSection.firstObjectIndex, beatmapSection.lastObjectIndex)
+                    .slice(beatmapSection.firstObjectIndex, beatmapSection.lastObjectIndex + 1)
                     .reduce((acc, value) => acc +
                     value.originalTapStrain /
-                        ThreeFingerChecker.strainThreshold, 0), 0.85);
-                // 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);
+                        ThreeFingerChecker.strainThreshold, 0), 0.875);
                 // 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.8), 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);
+                let fingerFactor = 1;
+                for (let i = 0, penaltyIndex = 1; i < cursorAmounts.length; ++i) {
+                    if (validIndexes.includes(i)) {
+                        continue;
+                    }
+                    fingerFactor += Math.pow((penaltyIndex * cursorAmounts[i] * objectCount) /
+                        this.strainNoteCount, 0.8);
+                    ++penaltyIndex;
+                }
                 // 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({
@@ -672,4 +536,4 @@ exports.ThreeFingerChecker = ThreeFingerChecker;
  *
  * Increasing this number will result in less sections being flagged.
  */
-ThreeFingerChecker.strainThreshold = 175;
+ThreeFingerChecker.strainThreshold = 200;

package/dist/analysis/data/ThreeFingerBeatmapSection.js

@@ -3,13 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThreeFingerBeatmapSection = void 0;
 const BeatmapSection_1 = require("./BeatmapSection");
 /**
- * A section of a beatmap. This is used to detect dragged sections.
+ * A section of a beatmap with extra information used for detecting three-finger usage.
  */
 class ThreeFingerBeatmapSection extends BeatmapSection_1.BeatmapSection {
     constructor(values) {
         super(values.firstObjectIndex, values.lastObjectIndex);
-        this.isDragged = values.isDragged;
-        this.dragFingerIndex = values.dragFingerIndex;
+        this.mainFingerIndex = values.mainFingerIndex;
     }
 }
 exports.ThreeFingerBeatmapSection = ThreeFingerBeatmapSection;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rian8337/osu-droid-replay-analyzer",
-  "version": "1.4.12-alpha.4",
+  "version": "1.4.12-alpha.7",
   "description": "A replay analyzer for analyzing osu!droid replay files.",
   "keywords": [
     "osu",
@@ -45,5 +45,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f8898821f7630859d2d826692fcda1959ec0bfa1"
+  "gitHead": "3db8ea957f7c4f6bf018224232f9db054b90f9b8"
 }