@rian8337/osu-droid-replay-analyzer 1.4.12-alpha.2 → 1.4.12-alpha.5

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");
@@ -49,7 +50,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.
          *
@@ -121,7 +122,7 @@ class ThreeFingerChecker {
             return { is3Finger: false, penalty: 1 };
         }
         this.getBeatmapSections();
-        this.detectDragPlay();
+        this.assignFingerIndexes();
         this.getDetailedBeatmapSections();
         this.preventAccidentalTaps();
         if (this.downCursorInstances.filter((v) => v.size > 0).length <= 3) {
@@ -147,11 +148,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 +166,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 +200,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 +217,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 +245,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 +274,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;
-            }
-            // 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.data.cursorMovement[i].size > 0) {
+                validCursorIndexes.add(i);
             }
-            // 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 === 1) {
                 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 +409,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,
                 });
             }
         }
@@ -525,15 +474,15 @@ class ThreeFingerChecker {
         // 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 mainIndex = beatmapSection.mainFingerIndex;
             const startTime = objects[beatmapSection.firstObjectIndex].object.startTime +
                 (objectData[beatmapSection.firstObjectIndex].result !==
-                    __1.hitResult.RESULT_0
+                    hitResult_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
+                    hitResult_1.hitResult.RESULT_0
                     ? objectData[beatmapSection.lastObjectIndex].accuracy
                     : this.hitWindow.hitWindowFor50(isPrecise));
             // Filter cursor instances during section.
@@ -550,10 +499,6 @@ class ThreeFingerChecker {
             const cursorAmounts = [];
             const cursorVectorTimes = [];
             for (let i = 0; i < this.downCursorInstances.length; ++i) {
-                // Do not include drag cursor instance.
-                if (i === dragIndex) {
-                    continue;
-                }
                 const cursorData = this.downCursorInstances[i];
                 let amount = 0;
                 for (let j = 0; j < cursorData.size; ++j) {
@@ -568,18 +513,25 @@ class ThreeFingerChecker {
                 }
                 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);
+            let validCursorPressCount = 0;
+            let invalidCursorPressCount = 0;
+            const validIndexes = [];
+            for (let i = 0; i < cursorAmounts.length; ++i) {
+                // Ignore the main cursor index.
+                if (i === mainIndex) {
+                    continue;
+                }
+                // Add 2f cursor presses to valid cursor count and the rest to invalid cursor count.
+                if (validIndexes.length <= 2) {
+                    validCursorPressCount += cursorAmounts[i];
+                }
+                else {
+                    invalidCursorPressCount += cursorAmounts[i];
+                }
+                validIndexes.push(i);
+            }
+            validIndexes.push(mainIndex);
+            const threeFingerRatio = invalidCursorPressCount / validCursorPressCount;
             const similarPresses = [];
             for (const cursorVectorTime of cursorVectorTimes) {
                 const pressIndex = similarPresses.findIndex((v) => v.vector.getDistance(cursorVectorTime.vector) <=
@@ -627,25 +579,29 @@ class ThreeFingerChecker {
                     .slice(beatmapSection.firstObjectIndex, beatmapSection.lastObjectIndex)
                     .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 +
+                let fingerFactor = 1;
+                if (threeFingerRatio > this.threeFingerRatioThreshold) {
+                    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;
+                    }
+                }
+                else {
+                    fingerFactor = 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);
+                            this.strainNoteCount, 0.2), 1), 0.25);
+                }
                 // 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({

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.2",
+  "version": "1.4.12-alpha.5",
   "description": "A replay analyzer for analyzing osu!droid replay files.",
   "keywords": [
     "osu",
@@ -33,7 +33,7 @@
   "dependencies": {
     "@rian8337/osu-base": "^1.4.8",
     "@rian8337/osu-difficulty-calculator": "^1.4.8",
-    "@rian8337/osu-rebalance-difficulty-calculator": "^1.4.12-alpha.2",
+    "@rian8337/osu-rebalance-difficulty-calculator": "^1.4.12-alpha.4",
     "java-deserialization": "^0.1.0",
     "unzipper": "^0.10.11"
   },
@@ -45,5 +45,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "9e03096bfdc8a36d6227b1c3723afba845ba92d7"
+  "gitHead": "9e42f2db1fa53115f7dcca1a6f09802267c3fe29"
 }