@rian8337/osu-droid-replay-analyzer 4.0.0-beta.21 → 4.0.0-beta.23

package/dist/index.js

@@ -339,6 +339,9 @@ class RebalanceThreeFingerChecker {
         this.isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
         this.hitWindow = new osuBase.DroidHitWindow(od);
         this.hitObjects = beatmap.hitObjects.objects;
+        this.objectRadiusThreshold = this.hitObjects[0].radius;
+        // Only allow object radius threshold to deviate slightly from actual object radius.
+        this.maximumObjectRadiusThreshold = this.objectRadiusThreshold * 1.05;
     }
     /**
      * Checks whether a beatmap is eligible to be detected for 3-finger.
@@ -575,42 +578,32 @@ class RebalanceThreeFingerChecker {
     findDragIndex(section) {
         var _a;
         const objectData = this.data.hitObjectData;
+        const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
         const firstObject = this.hitObjects[section.firstObjectIndex];
+        const firstObjectData = objectData[section.firstObjectIndex];
         const lastObject = this.hitObjects[section.lastObjectIndex];
-        let firstObjectMinHitTime = firstObject.startTime;
-        if (firstObject instanceof osuBase.Circle) {
-            switch (objectData[section.firstObjectIndex].result) {
-                case exports.HitResult.great:
-                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor300(this.isPrecise);
-                    break;
-                case exports.HitResult.good:
-                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor100(this.isPrecise);
-                    break;
-                default:
-                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
-            }
+        const lastObjectData = objectData[section.lastObjectIndex];
+        let firstObjectHitTime = firstObject.startTime;
+        let lastObjectHitTime = lastObject.startTime;
+        // Check for slider breaks.
+        if (firstObject instanceof osuBase.Slider &&
+            firstObjectData.accuracy === Math.floor(hitWindow50) + 13) {
+            firstObjectHitTime -= hitWindow50;
         }
-        else if (firstObject instanceof osuBase.Slider) {
-            firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
+        else {
+            firstObjectHitTime += firstObjectData.accuracy;
         }
-        let lastObjectMaxHitTime = lastObject.startTime;
-        if (lastObject instanceof osuBase.Circle) {
-            switch (objectData[section.lastObjectIndex].result) {
-                case exports.HitResult.great:
-                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor300(this.isPrecise);
-                    break;
-                case exports.HitResult.good:
-                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor100(this.isPrecise);
-                    break;
-                default:
-                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(this.isPrecise);
-            }
+        if (lastObject instanceof osuBase.Slider &&
+            lastObjectData.accuracy === Math.floor(hitWindow50) + 13) {
+            lastObjectHitTime += Math.min(hitWindow50, lastObject.nestedHitObjects[1].startTime - lastObject.startTime);
         }
-        else if (lastObject instanceof osuBase.Slider) {
-            lastObjectMaxHitTime += Math.min(this.hitWindow.hitWindowFor50(this.isPrecise), lastObject.spanDuration);
+        else {
+            lastObjectHitTime += lastObjectData.accuracy;
         }
         // Since there may be more than 1 cursor instance index,
         // we check which cursor instance follows hitobjects all over.
+        const cursorInstanceIndices = [];
+        const cursorGroupIndices = [];
         const cursorIndices = [];
         for (let i = 0; i < this.data.cursorMovement.length; ++i) {
             const c = this.data.cursorMovement[i];
@@ -619,8 +612,8 @@ class RebalanceThreeFingerChecker {
             }
             // Do not include cursors that don't have an occurence in this section
             // this speeds up checking process.
-            if (c.occurrenceGroups.filter((v) => v.startTime >= firstObjectMinHitTime &&
-                v.endTime <= lastObjectMaxHitTime).length === 0) {
+            if (c.occurrenceGroups.filter((v) => v.startTime <= firstObjectHitTime &&
+                v.endTime >= lastObjectHitTime).length === 0) {
                 continue;
             }
             // If this cursor instance doesn't move, it's not the cursor instance we want.
@@ -628,12 +621,15 @@ class RebalanceThreeFingerChecker {
                 0) {
                 continue;
             }
-            cursorIndices.push(i);
+            cursorInstanceIndices.push(i);
+            cursorGroupIndices.push(0);
+            // Start checking from the second cursor.
+            cursorIndices.push(1);
         }
         const sectionObjects = this.hitObjects.slice(section.firstObjectIndex, section.lastObjectIndex + 1);
         const sectionReplayObjectData = objectData.slice(section.firstObjectIndex, section.lastObjectIndex + 1);
-        const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
-        for (let i = 0; i < sectionObjects.length && cursorIndices.some((v) => v !== -1); ++i) {
+        for (let i = 0; i < sectionObjects.length &&
+            cursorInstanceIndices.some((v) => v !== -1); ++i) {
             const object = sectionObjects[i];
             const objectData = sectionReplayObjectData[i];
             if (object instanceof osuBase.Spinner ||
@@ -648,45 +644,70 @@ class RebalanceThreeFingerChecker {
             const objectPosition = object.getStackedPosition(osuBase.Modes.droid);
             const hitTime = object.startTime + objectData.accuracy;
             // Observe the cursor position at the object's hit time.
-            for (let j = 0; j < cursorIndices.length; ++j) {
-                if (cursorIndices[j] === -1) {
+            for (let j = 0; j < cursorInstanceIndices.length; ++j) {
+                if (cursorInstanceIndices[j] === -1) {
                     continue;
                 }
-                const cursorData = this.data.cursorMovement[cursorIndices[j]];
-                const cursorGroup = cursorData.occurrenceGroups.find((v) => v.isActiveAt(hitTime));
-                if (!cursorGroup) {
-                    continue;
-                }
-                const cursors = cursorGroup.allOccurrences;
-                let isInObject = false;
-                for (let k = 1; k < cursors.length; ++k) {
-                    const cursor = cursors[k];
-                    const prevCursor = cursors[k - 1];
-                    // Only consider cursor at interval prev.time <= hitTime <= current.time.
-                    if (prevCursor.time <= hitTime && cursor.time >= hitTime) {
+                const cursorData = this.data.cursorMovement[cursorInstanceIndices[j]];
+                for (let k = cursorGroupIndices[j]; k < cursorData.occurrenceGroups.length; cursorGroupIndices[j] = ++k) {
+                    const cursorGroup = cursorData.occurrenceGroups[k];
+                    if (!cursorGroup.isActiveAt(hitTime)) {
+                        continue;
+                    }
+                    const cursors = cursorGroup.allOccurrences;
+                    // We are maintaining the closest distance of cursors to the object.
+                    // This is because the radius that is calculated is using an estimation. As such,
+                    // it does not perfectly reflect the actual object radius in gameplay.
+                    let closestDistance = this.maximumObjectRadiusThreshold;
+                    for (let l = cursorIndices[j]; l < cursors.length; cursorIndices[j] = ++l) {
+                        const cursor = cursors[l];
+                        const prevCursor = cursors[l - 1];
+                        // Cursor is past the object's hit time.
+                        if (prevCursor.time > hitTime) {
+                            break;
+                        }
+                        // Cursor is before the object's hit time.
+                        if (hitTime > cursor.time) {
+                            continue;
+                        }
+                        let distance;
                         switch (cursor.id) {
                             case exports.MovementType.up:
-                                isInObject =
-                                    prevCursor.position.getDistance(objectPosition) <= object.radius;
+                                distance =
+                                    prevCursor.position.getDistance(objectPosition);
                                 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;
+                                const cursorPosition = osuBase.Interpolation.lerp(prevCursor.position, cursor.position, t);
+                                distance =
+                                    objectPosition.getDistance(cursorPosition);
+                                break;
                             }
+                            case exports.MovementType.down:
+                                continue;
                         }
-                        break;
+                        closestDistance = Math.min(closestDistance, distance);
                     }
+                    // At this point, the object is guaranteed to be hit, but the distance may not reach the threshold
+                    // due to radius estimation. In order to work around this, we store the farthest distance from all
+                    // processed cursors so far and use it as threshold rather than the actual object radius.
+                    if (closestDistance <= this.maximumObjectRadiusThreshold &&
+                        closestDistance > this.objectRadiusThreshold) {
+                        this.objectRadiusThreshold = closestDistance;
+                    }
+                    if (closestDistance > this.objectRadiusThreshold) {
+                        cursorInstanceIndices[j] = -1;
+                    }
+                    break;
                 }
-                if (!isInObject) {
-                    cursorIndices[j] = -1;
-                }
+                // The previous object may still be hit with the same cursor group or cursor index.
+                cursorGroupIndices[j] = Math.max(0, cursorGroupIndices[j] - 1);
+                cursorIndices[j] = Math.max(1, cursorIndices[j] - 1);
             }
         }
-        return (_a = cursorIndices.find((v) => v !== -1)) !== null && _a !== void 0 ? _a : -1;
+        return (_a = cursorInstanceIndices.find((v) => v !== -1)) !== null && _a !== void 0 ? _a : -1;
     }
     /**
      * Creates nerf factors by scanning through objects.
@@ -1747,7 +1768,7 @@ class TwoHandChecker {
                             }
                             const t = (cursorGroup.down.time - prevCursor.time) /
                                 (cursor.time - prevCursor.time);
-                            cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
+                            cursorPosition = osuBase.Interpolation.lerp(prevCursor.position, cursor.position, t);
                             const distance = cursorPosition.getDistance(objectPosition);
                             if (distance <
                                 nearestPosition.getDistance(objectPosition)) {
@@ -1843,7 +1864,7 @@ class TwoHandChecker {
                             const prevCursor = cursors[k - 1];
                             const t = osuBase.MathUtils.clamp((object.endTime - prevCursor.time) /
                                 (cursor.time - prevCursor.time), 0, 1);
-                            cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
+                            cursorPosition = osuBase.Interpolation.lerp(prevCursor.position, cursor.position, t);
                             break;
                         }
                     }
@@ -2169,12 +2190,6 @@ class ReplayAnalyzer {
          * The amount of two-handed objects.
          */
         this.twoHandedNoteCount = 0;
-        // Sizes of primitive data types in Java (in bytes)
-        this.BYTE_LENGTH = 1;
-        this.SHORT_LENGTH = 2;
-        this.INT_LENGTH = 4;
-        this.FLOAT_LENGTH = 4;
-        this.LONG_LENGTH = 8;
         this.scoreID = values.scoreID;
         this.beatmap = values.map;
         this.difficultyAttributes = values.difficultyAttributes;
@@ -2383,34 +2398,27 @@ class ReplayAnalyzer {
         }
         // Merge all cursor movement and hit object data section into one for better control when parsing
         const replayDataBuffer = Buffer.concat(replayDataBufferArray);
-        let bufferCounter = 0;
-        const size = replayDataBuffer.readInt32BE(bufferCounter);
-        bufferCounter += this.INT_LENGTH;
+        const bufferCounter = { counter: 0 };
+        const size = this.readInt(replayDataBuffer, bufferCounter);
         // Parse movement data
         for (let x = 0; x < size; x++) {
-            const moveSize = replayDataBuffer.readInt32BE(bufferCounter);
-            bufferCounter += this.INT_LENGTH;
+            const moveSize = this.readInt(replayDataBuffer, bufferCounter);
             const time = [];
             const x = [];
             const y = [];
             const id = [];
             for (let i = 0; i < moveSize; i++) {
-                time[i] = replayDataBuffer.readInt32BE(bufferCounter);
-                bufferCounter += this.INT_LENGTH;
+                time[i] = this.readInt(replayDataBuffer, bufferCounter);
                 id[i] = time[i] & 3;
                 time[i] >>= 2;
                 if (id[i] !== exports.MovementType.up) {
                     if (resultObject.replayVersion >= 5) {
-                        x[i] = replayDataBuffer.readFloatBE(bufferCounter);
-                        bufferCounter += this.FLOAT_LENGTH;
-                        y[i] = replayDataBuffer.readFloatBE(bufferCounter);
-                        bufferCounter += this.FLOAT_LENGTH;
+                        x[i] = this.readFloat(replayDataBuffer, bufferCounter);
+                        y[i] = this.readFloat(replayDataBuffer, bufferCounter);
                     }
                     else {
-                        x[i] = replayDataBuffer.readInt16BE(bufferCounter);
-                        bufferCounter += this.SHORT_LENGTH;
-                        y[i] = replayDataBuffer.readInt16BE(bufferCounter);
-                        bufferCounter += this.SHORT_LENGTH;
+                        x[i] = this.readShort(replayDataBuffer, bufferCounter);
+                        y[i] = this.readShort(replayDataBuffer, bufferCounter);
                     }
                 }
                 else {
@@ -2426,8 +2434,7 @@ class ReplayAnalyzer {
                 id: id,
             }));
         }
-        const replayObjectLength = replayDataBuffer.readInt32BE(bufferCounter);
-        bufferCounter += this.INT_LENGTH;
+        const replayObjectLength = this.readInt(replayDataBuffer, bufferCounter);
         // Parse result data
         for (let i = 0; i < replayObjectLength; i++) {
             const replayObjectData = {
@@ -2435,16 +2442,12 @@ class ReplayAnalyzer {
                 tickset: [],
                 result: exports.HitResult.miss,
             };
-            replayObjectData.accuracy =
-                replayDataBuffer.readInt16BE(bufferCounter);
-            bufferCounter += this.SHORT_LENGTH;
-            const len = replayDataBuffer.readInt8(bufferCounter);
-            bufferCounter += this.BYTE_LENGTH;
+            replayObjectData.accuracy = this.readShort(replayDataBuffer, bufferCounter);
+            const len = this.readByte(replayDataBuffer, bufferCounter);
             if (len > 0) {
                 const bytes = [];
                 for (let j = 0; j < len; j++) {
-                    bytes.push(replayDataBuffer.readInt8(bufferCounter));
-                    bufferCounter += this.BYTE_LENGTH;
+                    bytes.push(this.readByte(replayDataBuffer, bufferCounter));
                 }
                 // Int/int division in Java; numbers must be truncated to get actual number
                 for (let j = 0; j < len * 8; j++) {
@@ -2454,9 +2457,7 @@ class ReplayAnalyzer {
                 }
             }
             if (resultObject.replayVersion >= 1) {
-                replayObjectData.result =
-                    replayDataBuffer.readInt8(bufferCounter);
-                bufferCounter += this.BYTE_LENGTH;
+                replayObjectData.result = this.readByte(replayDataBuffer, bufferCounter);
             }
             resultObject.hitObjectData.push(replayObjectData);
         }
@@ -2570,21 +2571,24 @@ class ReplayAnalyzer {
      */
     convertDroidMods(replayMods) {
         const replayModsConstants = {
-            MOD_NOFAIL: "n",
-            MOD_EASY: "e",
-            MOD_HIDDEN: "h",
-            MOD_HARDROCK: "r",
-            MOD_DOUBLETIME: "d",
-            MOD_HALFTIME: "t",
-            MOD_NIGHTCORE: "c",
-            MOD_PRECISE: "s",
-            MOD_SMALLCIRCLE: "m",
-            MOD_SPEEDUP: "b",
-            MOD_REALLYEASY: "l",
-            MOD_PERFECT: "f",
-            MOD_SUDDENDEATH: "u",
-            MOD_SCOREV2: "v",
-            MOD_FLASHLIGHT: "i",
+            MOD_AUTO: new osuBase.ModAuto().droidString,
+            MOD_AUTOPILOT: new osuBase.ModAutopilot().droidString,
+            MOD_NOFAIL: new osuBase.ModNoFail().droidString,
+            MOD_EASY: new osuBase.ModEasy().droidString,
+            MOD_HIDDEN: new osuBase.ModHidden().droidString,
+            MOD_HARDROCK: new osuBase.ModHardRock().droidString,
+            MOD_DOUBLETIME: new osuBase.ModDoubleTime().droidString,
+            MOD_HALFTIME: new osuBase.ModHalfTime().droidString,
+            MOD_NIGHTCORE: new osuBase.ModNightCore().droidString,
+            MOD_PRECISE: new osuBase.ModPrecise().droidString,
+            MOD_SMALLCIRCLE: new osuBase.ModSmallCircle().droidString,
+            MOD_SPEEDUP: new osuBase.ModSpeedUp().droidString,
+            MOD_REALLYEASY: new osuBase.ModReallyEasy().droidString,
+            MOD_RELAX: new osuBase.ModRelax().droidString,
+            MOD_PERFECT: new osuBase.ModPerfect().droidString,
+            MOD_SUDDENDEATH: new osuBase.ModSuddenDeath().droidString,
+            MOD_SCOREV2: new osuBase.ModScoreV2().droidString,
+            MOD_FLASHLIGHT: new osuBase.ModFlashlight().droidString,
         };
         let modString = "";
         for (const mod of replayMods) {
@@ -2694,6 +2698,26 @@ class ReplayAnalyzer {
         this.sliderCheesePenalty = sliderCheeseChecker.check();
         this.hasBeenCheckedForSliderCheesing = true;
     }
+    readByte(buffer, counter) {
+        const num = buffer.readInt8(counter.counter);
+        counter.counter += 1;
+        return num;
+    }
+    readShort(buffer, counter) {
+        const num = buffer.readInt16BE(counter.counter);
+        counter.counter += 2;
+        return num;
+    }
+    readInt(buffer, counter) {
+        const num = buffer.readInt32BE(counter.counter);
+        counter.counter += 4;
+        return num;
+    }
+    readFloat(buffer, counter) {
+        const num = buffer.readFloatBE(counter.counter);
+        counter.counter += 4;
+        return num;
+    }
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-droid-replay-analyzer",
-    "version": "4.0.0-beta.21",
+    "version": "4.0.0-beta.23",
     "description": "A replay analyzer for analyzing osu!droid replay files.",
     "keywords": [
         "osu",
@@ -34,9 +34,9 @@
         "url": "https://github.com/Rian8337/osu-droid-module/issues"
     },
     "dependencies": {
-        "@rian8337/osu-base": "^4.0.0-beta.19",
-        "@rian8337/osu-difficulty-calculator": "^4.0.0-beta.21",
-        "@rian8337/osu-rebalance-difficulty-calculator": "^4.0.0-beta.21",
+        "@rian8337/osu-base": "^4.0.0-beta.23",
+        "@rian8337/osu-difficulty-calculator": "^4.0.0-beta.23",
+        "@rian8337/osu-rebalance-difficulty-calculator": "^4.0.0-beta.23",
         "java-deserialization": "^0.1.0",
         "unzipper": "^0.10.11"
     },
@@ -46,5 +46,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "be2833348b74ce7b1ce9fff3fd29af04b778955e"
+    "gitHead": "62063ddac57c3a60426c7206268a0573cc6db6dd"
 }

package/typings/index.d.ts

@@ -572,6 +572,14 @@ declare class RebalanceThreeFingerChecker {
      * Whether this score uses the Precise mod.
      */
     private readonly isPrecise;
+    /**
+     * The maximum object radius that is acceptable when checking for cursor position in drag detection.
+     */
+    private objectRadiusThreshold;
+    /**
+     * The maximum value of object radius threshold.
+     */
+    private readonly maximumObjectRadiusThreshold;
     /**
      * @param beatmap The beatmap to analyze.
      * @param data The data of the replay.
@@ -733,11 +741,6 @@ declare class ReplayAnalyzer {
      */
     twoHandedNoteCount: number;
     private convertedBeatmap?;
-    private readonly BYTE_LENGTH;
-    private readonly SHORT_LENGTH;
-    private readonly INT_LENGTH;
-    private readonly FLOAT_LENGTH;
-    private readonly LONG_LENGTH;
     constructor(values: {
         /**
          * The ID of the score.
@@ -802,6 +805,10 @@ declare class ReplayAnalyzer {
      * Requires `analyze()` to be called first and `map` and `difficultyAttributes` to be defined.
      */
     checkForSliderCheesing(): void;
+    private readByte;
+    private readShort;
+    private readInt;
+    private readFloat;
 }
 
 /**