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

package/dist/index.js

@@ -29,25 +29,45 @@ function _interopNamespace(e) {
 
 var javaDeserialization__namespace = /*#__PURE__*/_interopNamespace(javaDeserialization);
 
+/**
+ * Represents a cursor's occurrence.
+ */
+class CursorOccurrence {
+    /**
+     * The time of this occurrence.
+     */
+    time;
+    /**
+     * The position of the occurrence.
+     */
+    position;
+    /**
+     * The movement ID of the occurrence.
+     */
+    id;
+    constructor(time, x, y, id) {
+        this.time = time;
+        this.position = new osuBase.Vector2(x, y);
+        this.id = id;
+    }
+}
+
 /**
  * Represents a cursor instance in an osu!droid replay.
  *
- * Stores cursor movement data such as x and y coordinates, movement size, etc.
+ * Stores cursor movement data in the form of `CursorOccurrence`s.
  *
  * This is used when analyzing replays using replay analyzer.
  */
 class CursorData {
-    size;
-    time;
-    x;
-    y;
-    id;
+    /**
+     * The occurrences of this cursor instance.
+     */
+    occurrences = [];
     constructor(values) {
-        this.size = values.size;
-        this.time = values.time;
-        this.x = values.x;
-        this.y = values.y;
-        this.id = values.id;
+        for (let i = 0; i < values.size; ++i) {
+            this.occurrences.push(new CursorOccurrence(values.time[i], values.x[i], values.y[i], values.id[i]));
+        }
     }
 }
 
@@ -352,14 +372,16 @@ class ThreeFingerChecker {
         }
         this.getAccurateBreakPoints();
         this.filterCursorInstances();
-        if (this.downCursorInstances.filter((v) => v.size > 0).length <= 3) {
+        if (this.downCursorInstances.filter((v) => v.occurrences.length > 0)
+            .length <= 3) {
             return { is3Finger: false, penalty: 1 };
         }
         this.getBeatmapSections();
         this.detectDragPlay();
         this.getDetailedBeatmapSections();
         this.preventAccidentalTaps();
-        if (this.downCursorInstances.filter((v) => v.size > 0).length <= 3) {
+        if (this.downCursorInstances.filter((v) => v.occurrences.length > 0)
+            .length <= 3) {
             return { is3Finger: false, penalty: 1 };
         }
         this.calculateNerfFactors();
@@ -478,22 +500,18 @@ class ThreeFingerChecker {
                 y: [],
                 id: [],
             });
-            for (let j = 0; j < cursorInstance.size; ++j) {
-                if (cursorInstance.id[j] !== exports.movementType.DOWN) {
+            for (let j = 0; j < cursorInstance.occurrences.length; ++j) {
+                if (cursorInstance.occurrences[j].id !== exports.movementType.DOWN) {
                     continue;
                 }
-                const time = cursorInstance.time[j];
+                const time = cursorInstance.occurrences[j].time;
                 if (time < firstObjectHitTime || time > lastObjectHitTime) {
                     continue;
                 }
                 if (this.breakPointAccurateTimes.some((v) => time >= v.startTime && time <= v.endTime)) {
                     continue;
                 }
-                ++newCursorData.size;
-                newCursorData.time.push(time);
-                newCursorData.x.push(cursorInstance.x[j]);
-                newCursorData.y.push(cursorInstance.y[j]);
-                newCursorData.id.push(cursorInstance.id[j]);
+                newCursorData.occurrences.push(new CursorOccurrence(time, cursorInstance.occurrences[j].position.x, cursorInstance.occurrences[j].position.y, cursorInstance.occurrences[j].id));
             }
             this.downCursorInstances.push(newCursorData);
         }
@@ -579,16 +597,18 @@ class ThreeFingerChecker {
         const cursorIndexes = [];
         for (let i = 0; i < this.data.cursorMovement.length; ++i) {
             const c = this.data.cursorMovement[i];
-            if (c.size === 0) {
+            if (c.occurrences.length === 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) {
+            if (c.occurrences.filter((v) => v.time >= firstObjectMinHitTime &&
+                v.time <= 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 === exports.movementType.MOVE).length === 0) {
+            if (c.occurrences.filter((v) => v.id === exports.movementType.MOVE)
+                .length === 0) {
                 continue;
             }
             cursorIndexes.push(i);
@@ -625,27 +645,28 @@ class ThreeFingerChecker {
                 // 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 nextHitIndex = c.occurrences.findIndex((v) => v.time >= hitTime);
                 const hitIndex = nextHitIndex - 1;
                 if (hitIndex <= -1) {
                     cursorIndexes[j] = -1;
                     continue;
                 }
-                if (c.id[hitIndex] === exports.movementType.UP) {
+                if (c.occurrences[hitIndex].id === exports.movementType.UP) {
                     cursorIndexes[j] = -1;
                     continue;
                 }
-                const cursorPosition = new osuBase.Vector2(c.x[hitIndex], c.y[hitIndex]);
+                const cursorPosition = new osuBase.Vector2(c.occurrences[hitIndex].position.x, c.occurrences[hitIndex].position.y);
                 let isInObject = false;
-                if (c.id[nextHitIndex] === exports.movementType.MOVE ||
-                    c.id[hitIndex] === exports.movementType.MOVE) {
+                if (c.occurrences[nextHitIndex].id === exports.movementType.MOVE ||
+                    c.occurrences[hitIndex].id === exports.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 = osuBase.Interpolation.lerp(c.x[hitIndex], c.x[nextHitIndex], t);
-                        cursorPosition.y = osuBase.Interpolation.lerp(c.y[hitIndex], c.y[nextHitIndex], t);
+                    for (let mSecPassed = c.occurrences[hitIndex].time; mSecPassed <= c.occurrences[nextHitIndex].time; ++mSecPassed) {
+                        const t = (mSecPassed - c.occurrences[nextHitIndex].time) /
+                            (c.occurrences[hitIndex].time -
+                                c.occurrences[nextHitIndex].time);
+                        cursorPosition.x = osuBase.Interpolation.lerp(c.occurrences[hitIndex].position.x, c.occurrences[nextHitIndex].position.x, t);
+                        cursorPosition.y = osuBase.Interpolation.lerp(c.occurrences[hitIndex].position.y, c.occurrences[nextHitIndex].position.y, t);
                         if (o.object.stackedPosition.getDistance(cursorPosition) <= o.object.radius) {
                             isInObject = true;
                             break;
@@ -718,32 +739,24 @@ class ThreeFingerChecker {
      * unnecessary taps.
      */
     preventAccidentalTaps() {
-        let filledCursorAmount = this.downCursorInstances.filter((v) => v.size > 0).length;
+        let filledCursorAmount = this.downCursorInstances.filter((v) => v.occurrences.length > 0).length;
         if (filledCursorAmount <= 3) {
             return;
         }
         const objects = this.map.objects;
-        const totalCursorAmount = this.downCursorInstances.reduce((acc, value) => acc + value.size, 0);
+        const totalCursorAmount = this.downCursorInstances.reduce((acc, value) => acc + value.occurrences.length, 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 <=
+            if (cursorInstance.occurrences.length <=
                 Math.ceil(objects.length / this.accidentalTapThreshold) &&
-                cursorInstance.size / totalCursorAmount <
+                cursorInstance.occurrences.length / totalCursorAmount <
                     this.threeFingerRatioThreshold * 2) {
                 --filledCursorAmount;
-                for (const property in cursorInstance) {
-                    const prop = property;
-                    if (Array.isArray(cursorInstance[prop])) {
-                        cursorInstance[prop].length = 0;
-                    }
-                    else {
-                        cursorInstance[prop] = 0;
-                    }
-                }
+                cursorInstance.occurrences.length = 0;
             }
             this.downCursorInstances[i] = cursorInstance;
         }
@@ -773,13 +786,9 @@ class ThreeFingerChecker {
                     : this.hitWindow.hitWindowFor50(isPrecise));
             // Filter cursor instances during section.
             this.downCursorInstances.forEach((c) => {
-                const i = c.time.findIndex((t) => t >= startTime);
+                const i = c.occurrences.findIndex((t) => t.time >= 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);
+                    c.occurrences = c.occurrences.slice(0, i);
                 }
             });
             const cursorAmounts = [];
@@ -791,13 +800,13 @@ class ThreeFingerChecker {
                 }
                 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) {
+                for (let j = 0; j < cursorData.occurrences.length; ++j) {
+                    if (cursorData.occurrences[j].time >= startTime &&
+                        cursorData.occurrences[j].time <= endTime) {
                         ++amount;
                         cursorVectorTimes.push({
-                            vector: new osuBase.Vector2(cursorData.x[j], cursorData.y[j]),
-                            time: cursorData.time[j],
+                            vector: new osuBase.Vector2(cursorData.occurrences[j].position.x, cursorData.occurrences[j].position.y),
+                            time: cursorData.occurrences[j].time,
                         });
                     }
                 }
@@ -936,10 +945,6 @@ class TwoHandChecker {
      * The data of the replay.
      */
     data;
-    /**
-     * A cursor data array that only contains `movementType.DOWN` and `movementType.MOVE` movement ID occurrences.
-     */
-    downMoveCursorInstances = [];
     /**
      * The hitobjects of the beatmap that have been assigned with their respective cursor index.
      */
@@ -955,6 +960,18 @@ class TwoHandChecker {
      * those that do not worth any strain.
      */
     minCursorIndexCount = 5;
+    /**
+     * The approximated difficulty of the current object such that the object is likely to be 2-handed by a player.
+     *
+     * This scales with an object's angle and speed relative to the previous object.
+     * Acute angles or fast speed will accumulate this number. Conversely, wide angles or slow speed will decay this number.
+     */
+    currentAngleDiffApproxDefault = 10;
+    /**
+     * The threshold at which objects will be started getting considered to be 2-handable.
+     */
+    currentAngleDiffApproxThreshold = 200;
+    assignCurrentIndexToOne = false;
     /**
      * @param map The beatmap to analyze.
      * @param data The data of the replay.
@@ -974,56 +991,35 @@ class TwoHandChecker {
      * Checks if a beatmap is two-handed.
      */
     check() {
-        this.filterCursorInstances();
-        if (this.downMoveCursorInstances.filter((v) => v.size > 0).length <= 1) {
+        if (this.data.cursorMovement.filter((v) => v.occurrences.length > 0)
+            .length <= 1) {
             return false;
         }
         this.indexHitObjects();
         this.applyPenalty();
         return true;
     }
-    /**
-     * Filters the original cursor instances, returning only those with `movementType.DOWN` and `movementType.MOVE` movement ID.
-     */
-    filterCursorInstances() {
-        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            const cursorInstance = this.data.cursorMovement[i];
-            const newCursorData = {
-                size: 0,
-                time: [],
-                x: [],
-                y: [],
-                id: [],
-            };
-            for (let j = 0; j < cursorInstance.size; ++j) {
-                if (cursorInstance.id[j] === exports.movementType.UP) {
-                    continue;
-                }
-                ++newCursorData.size;
-                newCursorData.time.push(cursorInstance.time[j]);
-                newCursorData.x.push(cursorInstance.x[j]);
-                newCursorData.y.push(cursorInstance.y[j]);
-                newCursorData.id.push(cursorInstance.id[j]);
-            }
-            this.downMoveCursorInstances.push(newCursorData);
-        }
-    }
     /**
      * Converts hitobjects into indexed hit objects.
      */
     indexHitObjects() {
-        const objects = this.map.objects;
-        const objectData = this.data.hitObjectData;
+        const hitWindowOffset = this.getHitWindowOffset();
         const indexes = [];
+        let overallDiffApprox = this.currentAngleDiffApproxDefault;
         for (let i = 0; i < this.map.objects.length; ++i) {
-            const current = objects[i];
-            const currentData = objectData[i];
-            const index = this.getCursorIndex(current, currentData);
+            const diff = i > 0 ? this.getSpacingAngleDiffApprox(i) : 1;
+            overallDiffApprox = osuBase.MathUtils.clamp(overallDiffApprox * diff, this.currentAngleDiffApproxDefault, this.currentAngleDiffApproxThreshold + 100);
+            const index = overallDiffApprox >= this.currentAngleDiffApproxThreshold
+                ? this.getCursorIndex(i, hitWindowOffset)
+                : 0;
             indexes.push(index);
-            this.indexedHitObjects.push(new IndexedHitObject(current, index));
+            this.indexedHitObjects.push(new IndexedHitObject(this.map.objects[i], index));
         }
+        // const notFound = this.indexedHitObjects.filter(v => v.cursorIndex === -1);
+        console.log("Spinners:", this.map.map.hitObjects.spinners);
+        console.log("Misses:", this.data.accuracy.nmiss);
         console.log(indexes.filter((v) => v !== -1).length, "cursors found,", indexes.filter((v) => v === -1).length, "not found");
-        const indexCounts = osuBase.Utils.initializeArray(this.downMoveCursorInstances.length, 0);
+        const indexCounts = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
         for (const index of indexes) {
             if (index === -1) {
                 continue;
@@ -1043,105 +1039,231 @@ class TwoHandChecker {
                 indexedHitObject.cursorIndex = mainCursorIndex;
             }
         });
-        for (let i = 0; i < this.downMoveCursorInstances.length; ++i) {
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
             console.log("Index", i, "count:", indexes.filter((v) => v === i).length);
         }
     }
+    /**
+     * Gets the approximation of an object's difficulty such that the object is likely to be 2-handed.
+     *
+     * @param index The index of the object.
+     */
+    getSpacingAngleDiffApprox(index) {
+        const object = this.map.objects[index];
+        if (object.object instanceof osuBase.Spinner) {
+            return 0.1;
+        }
+        const angleDiff = object.angle !== null
+            ? 0.5 + Math.pow(Math.cos(object.angle / 2), 2)
+            : 1;
+        const speedDiff = object.lazyJumpDistance / Math.max(1, object.deltaTime);
+        // Make decay slower.
+        return Math.max(0.8, angleDiff * speedDiff);
+    }
+    /**
+     * Gets the hit window offset to be applied to `getCursorIndex`.
+     */
+    getHitWindowOffset() {
+        const deltaTimes = [];
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const c = this.data.cursorMovement[i];
+            for (let j = 0; j < c.occurrences.length; ++j) {
+                if (c.occurrences[j].time <
+                    this.map.map.hitObjects.objects[0].startTime -
+                        this.hitWindow.hitWindowFor50()) {
+                    continue;
+                }
+                if (c.occurrences[j].id !== exports.movementType.MOVE) {
+                    continue;
+                }
+                const deltaTime = c.occurrences[j]?.time - c.occurrences[j - 1]?.time || 0;
+                if (deltaTime > 0) {
+                    deltaTimes.push(deltaTime);
+                }
+            }
+        }
+        return Math.min(...deltaTimes);
+    }
     /**
      * Gets the cursor index that hits the given object.
      *
-     * @param object The object to check.
-     * @param data The replay data of the object.
+     * @param index The index of the object to check.
+     * @param hitWindowOffset The offset for hit window to compensate for replay hit inaccuracies.
      * @returns The cursor index that hits the given object, -1 if the index is not found, the object is a spinner, or the object was missed.
      */
-    getCursorIndex(object, data) {
+    getCursorIndex(index, hitWindowOffset) {
+        const object = this.map.objects[index];
+        const data = this.data.hitObjectData[index];
         if (object.object instanceof osuBase.Spinner ||
             data.result === exports.hitResult.RESULT_0) {
             return -1;
         }
         const isPrecise = this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise);
-        let hitWindowLength;
-        switch (data.result) {
-            case exports.hitResult.RESULT_300:
-                hitWindowLength = this.hitWindow.hitWindowFor300(isPrecise);
-                break;
-            case exports.hitResult.RESULT_100:
-                hitWindowLength = this.hitWindow.hitWindowFor100(isPrecise);
-                break;
-            default:
-                hitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
+        const isSlider = object.object instanceof osuBase.Slider;
+        // For sliders, automatically set hit window to be as lenient as possible.
+        let hitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
+        if (!isSlider) {
+            switch (data.result) {
+                case exports.hitResult.RESULT_300:
+                    hitWindowLength = this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    hitWindowLength = this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+            }
         }
-        const hitTime = object.object.startTime;
-        const maximumHitTime = hitTime + hitWindowLength;
-        const minimumHitTime = hitTime - hitWindowLength;
+        const startTime = object.object.startTime;
+        const hitTime = startTime + data.accuracy;
+        const minimumHitTime = startTime - hitWindowLength - hitWindowOffset;
+        const maximumHitTime = startTime + hitWindowLength + hitWindowOffset;
         const cursorInformations = [];
-        for (let i = 0; i < this.downMoveCursorInstances.length; ++i) {
-            const c = this.downMoveCursorInstances[i];
-            let minDistance = Number.POSITIVE_INFINITY;
-            let minHitTime = 0;
-            for (let j = 0; j < c.size; ++j) {
-                if (c.time[j] < minimumHitTime) {
-                    continue;
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const c = this.data.cursorMovement[i];
+            if (c.occurrences.length === 0) {
+                continue;
+            }
+            let hitTimeBeforeIndex = osuBase.MathUtils.clamp(c.occurrences.findIndex((v) => v.time >= minimumHitTime), 1, c.occurrences.length - 1) - 1;
+            let hitTimeAfterIndex = c.occurrences.findIndex(
+            // There is a special case for sliders where the time leniency in droid is a lot bigger compared to PC.
+            // To prevent slider end time from ending earlier than hit window leniency, we use the maximum value between both.
+            (v) => v.time >= Math.max(object.object.endTime, maximumHitTime));
+            if (hitTimeAfterIndex === -1) {
+                // Maximum hit time or object end time may be out of bounds for every presses.
+                // We set the index to the latest cursor occurrence if that happens.
+                hitTimeAfterIndex = c.occurrences.length;
+            }
+            --hitTimeAfterIndex;
+            // Sometimes a `movementType.UP` instance occurs at the same time as a `movementType.MOVE`
+            // or a cursor is recorded twice in one time, therefore this check is required.
+            while (c.occurrences[hitTimeBeforeIndex]?.time ===
+                c.occurrences[hitTimeBeforeIndex - 1]?.time &&
+                hitTimeBeforeIndex > 0) {
+                --hitTimeBeforeIndex;
+            }
+            // We track the cursor movement along those indexes.
+            // Current cursor position is in `hitTimeBeforeIndex`.
+            let distance = Number.POSITIVE_INFINITY;
+            let acceptableRadius = object.object.radius;
+            // Sliders have a bigger radius tolerance due to slider ball.
+            if (isSlider) {
+                acceptableRadius *= 2.4;
+            }
+            let j = hitTimeBeforeIndex;
+            for (j; j <= hitTimeAfterIndex; ++j) {
+                const occurrence = c.occurrences[j];
+                const nextOccurrence = c.occurrences[j + 1];
+                const cursorPosition = occurrence.position;
+                if (occurrence.time > hitTime + hitWindowOffset + 10) {
+                    // Give an additional 10ms in case registration in-game is late.
+                    // Set distance to minimum just for the last.
+                    if (occurrence.id !== exports.movementType.UP) {
+                        distance = Math.min(distance, object.object.stackedPosition.getDistance(cursorPosition));
+                    }
+                    break;
                 }
-                // For some reason, some cursor instances repeat itself,
-                // so just skip it to save time.
-                if (c.time[j + 1] === c.time[j]) {
+                if (occurrence.id === exports.movementType.UP) {
                     continue;
                 }
-                if (c.time[j - 1] > maximumHitTime) {
-                    break;
+                distance =
+                    object.object.stackedPosition.getDistance(cursorPosition);
+                if (nextOccurrence &&
+                    nextOccurrence.id === exports.movementType.MOVE &&
+                    occurrence.time !== nextOccurrence.time &&
+                    !occurrence.position.equals(nextOccurrence.position)) {
+                    // If next cursor is a `move` instance and it doesn't go out of time
+                    // range, we interpolate cursor position between two occurrences.
+                    const nextPosition = nextOccurrence.position;
+                    const displacement = nextPosition.subtract(cursorPosition);
+                    for (let mSecPassed = Math.max(minimumHitTime, occurrence.time); mSecPassed <=
+                        Math.min(hitTime + hitWindowOffset, nextOccurrence.time); ++mSecPassed) {
+                        const progress = (mSecPassed - occurrence.time) /
+                            (nextOccurrence.time - occurrence.time);
+                        distance = object.object.stackedPosition.getDistance(cursorPosition.add(displacement.scale(progress)));
+                    }
                 }
-                let hitPosition = new osuBase.Vector2(c.x[j], c.y[j]);
-                let distanceToObject = object.object.stackedPosition.getDistance(hitPosition);
-                if (minDistance > distanceToObject) {
-                    minDistance = distanceToObject;
-                    minHitTime = c.time[j];
+            }
+            if (distance > acceptableRadius) {
+                continue;
+            }
+            let acceptedCursorIndex = i;
+            if (isSlider) {
+                this.assignCurrentIndexToOne = acceptedCursorIndex % 2 === 0;
+            }
+            else {
+                // Get the latest down instance.
+                while (c.occurrences[j]?.id !== exports.movementType.DOWN &&
+                    j > hitTimeBeforeIndex) {
+                    --j;
                 }
-                minDistance = Math.min(minDistance, object.object.stackedPosition.getDistance(hitPosition));
-                if (c.id[j + 1] === exports.movementType.MOVE ||
-                    c.id[j] === exports.movementType.MOVE) {
-                    // Interpolate cursor position between two occurrences
-                    const initialPosition = new osuBase.Vector2(c.x[j], c.y[j]);
-                    const nextPosition = new osuBase.Vector2(c.x[j + 1], c.y[j + 1]);
-                    const displacement = nextPosition.subtract(initialPosition);
-                    for (let mSecPassed = c.time[j]; mSecPassed <= Math.min(c.time[j + 1], maximumHitTime); ++mSecPassed) {
-                        const progress = (mSecPassed - c.time[j]) /
-                            (c.time[j + 1] - c.time[j]);
-                        hitPosition = initialPosition.add(displacement.scale(progress));
-                        distanceToObject =
-                            object.object.stackedPosition.getDistance(hitPosition);
-                        if (minDistance > distanceToObject) {
-                            minDistance = distanceToObject;
-                            minHitTime = mSecPassed;
+                if (c.occurrences[j].id === exports.movementType.DOWN) {
+                    let isAngleFulfilled = false;
+                    // Special case where a cursor is "dragged" into the next object.
+                    if (c.occurrences[j + 1]?.id === exports.movementType.MOVE &&
+                        c.occurrences[j + 2]?.id === exports.movementType.UP &&
+                        // Some move instances move in the exact same place. Not sure why, most likely
+                        // because the position is recorded as int in the game and the movement is too small to
+                        // convert into +1 or -1.
+                        !c.occurrences[j].position.equals(c.occurrences[j + 1].position)) {
+                        const movementVec = c.occurrences[j + 1].position.subtract(object.object.endPosition);
+                        if (this.map.objects[index + 1]) {
+                            const next = this.map.objects[index + 1];
+                            const currentToNext = next.object.stackedPosition.subtract(object.object.endPosition);
+                            const dot = currentToNext.dot(movementVec);
+                            const det = currentToNext.x * movementVec.y -
+                                currentToNext.y * movementVec.x;
+                            const movementToNextAngle = Math.abs(Math.atan2(det, dot));
+                            isAngleFulfilled =
+                                movementToNextAngle < Math.PI / 6;
                         }
+                        if (this.map.objects[index - 1] && !isAngleFulfilled) {
+                            const prev = this.map.objects[index - 1];
+                            const extendedCurrent = object.object.endPosition
+                                .subtract(prev.object.stackedPosition)
+                                .scale(1.5)
+                                .subtract(object.object.endPosition);
+                            const dot = extendedCurrent.dot(movementVec);
+                            const det = extendedCurrent.x * movementVec.y -
+                                extendedCurrent.y * movementVec.x;
+                            const extendedCurrentToMovementAngle = Math.abs(Math.atan2(det, dot));
+                            isAngleFulfilled =
+                                extendedCurrentToMovementAngle < Math.PI / 6;
+                        }
+                    }
+                    if (isAngleFulfilled) {
+                        this.assignCurrentIndexToOne = true;
+                        acceptedCursorIndex = 0;
+                    }
+                    else {
+                        acceptedCursorIndex = this.assignCurrentIndexToOne
+                            ? 1
+                            : 0;
+                        this.assignCurrentIndexToOne =
+                            !this.assignCurrentIndexToOne;
                     }
                 }
             }
-            if (minDistance <= object.object.radius) {
-                cursorInformations.push({
-                    cursorIndex: i,
-                    hitTimeDiff: Math.abs(minHitTime - hitTime),
-                });
-            }
-        }
-        if (cursorInformations.length === 0) {
-            return -1;
+            cursorInformations.push({
+                cursorIndex: acceptedCursorIndex,
+                distanceDiff: distance,
+            });
         }
-        // Now we look at which cursor is closest to hit time
-        const minHitTimeDiff = Math.min(...cursorInformations.map((v) => {
-            return v.hitTimeDiff;
+        // Cursors have been filtered to see which of them is inside the object.
+        // Now we look at which cursor is closest to the center of the object.
+        const minDistanceDiff = Math.min(...cursorInformations.map((v) => {
+            return v.distanceDiff;
         }));
-        return (cursorInformations.find((c) => c.hitTimeDiff === minHitTimeDiff)
-            ?.cursorIndex);
+        return (cursorInformations.find((c) => c.distanceDiff === minDistanceDiff)
+            ?.cursorIndex ?? -1);
     }
     /**
      * Applies penalty to the original star rating instance.
      */
     applyPenalty() {
-        const beatmaps = new Array(this.downMoveCursorInstances.length);
+        const beatmaps = new Array(this.data.cursorMovement.length);
         this.indexedHitObjects.forEach((o) => {
             if (!beatmaps[o.cursorIndex]) {
                 const map = osuBase.Utils.deepCopy(this.map.map);
+                map.hitObjects.clear();
                 beatmaps[o.cursorIndex] = map;
             }
             beatmaps[o.cursorIndex].hitObjects.add(o.object.object);
@@ -1155,14 +1277,12 @@ class TwoHandChecker {
             starRating.map = beatmap;
             starRating.generateDifficultyHitObjects();
             starRating.objects[0].deltaTime =
-                starRating.objects[0].object.startTime -
-                    this.indexedHitObjects[0].object.object.startTime;
-            starRating.objects[0].strainTime = Math.max(50, starRating.objects[0].deltaTime);
+                starRating.objects[0].startTime -
+                    this.indexedHitObjects[0].object.startTime;
+            starRating.objects[0].strainTime = Math.max(25, starRating.objects[0].deltaTime);
             this.map.objects.push(...starRating.objects);
         });
-        this.map.objects.sort((a, b) => {
-            return a.startTime - b.startTime;
-        });
+        this.map.objects.sort((a, b) => a.startTime - b.startTime);
         this.map.calculateAll();
     }
 }
@@ -1404,42 +1524,41 @@ class ReplayAnalyzer {
         for (let x = 0; x < size; x++) {
             const moveSize = replayDataBuffer.readInt32BE(bufferCounter);
             bufferCounter += this.INT_LENGTH;
-            const moveArray = {
-                size: moveSize,
-                time: [],
-                x: [],
-                y: [],
-                id: [],
-            };
+            const time = [];
+            const x = [];
+            const y = [];
+            const id = [];
             for (let i = 0; i < moveSize; i++) {
-                moveArray.time[i] = replayDataBuffer.readInt32BE(bufferCounter);
+                time[i] = replayDataBuffer.readInt32BE(bufferCounter);
                 bufferCounter += this.INT_LENGTH;
-                moveArray.id[i] = moveArray.time[i] & 3;
-                moveArray.time[i] >>= 2;
-                if (moveArray.id[i] !== exports.movementType.UP) {
+                id[i] = time[i] & 3;
+                time[i] >>= 2;
+                if (id[i] !== exports.movementType.UP) {
                     if (resultObject.replayVersion >= 5) {
-                        moveArray.x[i] =
-                            replayDataBuffer.readFloatBE(bufferCounter);
+                        x[i] = replayDataBuffer.readFloatBE(bufferCounter);
                         bufferCounter += this.FLOAT_LENGTH;
-                        moveArray.y[i] =
-                            replayDataBuffer.readFloatBE(bufferCounter);
+                        y[i] = replayDataBuffer.readFloatBE(bufferCounter);
                         bufferCounter += this.FLOAT_LENGTH;
                     }
                     else {
-                        moveArray.x[i] =
-                            replayDataBuffer.readInt16BE(bufferCounter);
+                        x[i] = replayDataBuffer.readInt16BE(bufferCounter);
                         bufferCounter += this.SHORT_LENGTH;
-                        moveArray.y[i] =
-                            replayDataBuffer.readInt16BE(bufferCounter);
+                        y[i] = replayDataBuffer.readInt16BE(bufferCounter);
                         bufferCounter += this.SHORT_LENGTH;
                     }
                 }
                 else {
-                    moveArray.x[i] = -1;
-                    moveArray.y[i] = -1;
+                    x[i] = -1;
+                    y[i] = -1;
                 }
             }
-            resultObject.cursorMovement.push(moveArray);
+            resultObject.cursorMovement.push(new CursorData({
+                size: moveSize,
+                time: time,
+                x: x,
+                y: y,
+                id: id,
+            }));
         }
         const replayObjectLength = replayDataBuffer.readInt32BE(bufferCounter);
         bufferCounter += this.INT_LENGTH;
@@ -1720,6 +1839,7 @@ class ReplayObjectData {
 }
 
 exports.CursorData = CursorData;
+exports.CursorOccurrence = CursorOccurrence;
 exports.ReplayAnalyzer = ReplayAnalyzer;
 exports.ReplayData = ReplayData;
 exports.ReplayObjectData = ReplayObjectData;