@rian8337/osu-droid-replay-analyzer 2.0.0-alpha.1 → 2.0.0-alpha.12

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.
      */
@@ -974,56 +979,28 @@ 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 = [];
         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 index = this.map.objects[i].aimStrainWithSliders >= 175
+                ? this.getCursorIndex(i, hitWindowOffset)
+                : -1;
             indexes.push(index);
-            this.indexedHitObjects.push(new IndexedHitObject(current, index));
+            this.indexedHitObjects.push(new IndexedHitObject(this.map.objects[i], index));
         }
-        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;
@@ -1033,7 +1010,8 @@ class TwoHandChecker {
         const mainCursorIndex = indexCounts.indexOf(Math.max(...indexCounts));
         const ignoredCursorIndexes = [];
         for (let i = 0; i < indexCounts.length; ++i) {
-            if (indexCounts[i] < this.minCursorIndexCount) {
+            if (indexCounts[i] < this.minCursorIndexCount &&
+                i !== mainCursorIndex) {
                 ignoredCursorIndexes.push(i);
             }
         }
@@ -1043,109 +1021,233 @@ class TwoHandChecker {
                 indexedHitObject.cursorIndex = mainCursorIndex;
             }
         });
-        for (let i = 0; i < this.downMoveCursorInstances.length; ++i) {
-            console.log("Index", i, "count:", indexes.filter((v) => v === i).length);
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            console.log("Index", i, "count:", this.indexedHitObjects.filter((v) => v.cursorIndex === i).length);
         }
     }
+    /**
+     * 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;
         }
+        if (object.object.startTime === 12514) {
+            console.log("Hi");
+        }
         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);
+        // For sliders, automatically set hit window to be as lenient as possible.
+        let hitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
+        if (!(object.object instanceof osuBase.Slider)) {
+            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 (object.object instanceof osuBase.Slider) {
+                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) {
+                    // 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;
+            }
+            // The case for a one-handed object is that there will be a slight movement in the cursor towards
+            // the next object in fast patterns. We should not be worried about slow patterns as they will only
+            // make a minimal difference and aim strain threshold should filter them out.
+            // In order to verify if the player does that, we check if the movement towards the next
+            // object is sufficient enough to be two-handed. This is done by checking if the movement
+            // from the current object to the next object and the movement from the current object
+            // to the significant move cursor occurrence produces an angle that is acute enough.
+            let isAngleFulfilled = false;
+            // For sliders, we need to consider two cases. The first case is when the player doesn't drag
+            // the slider. The second case is when the player drags the slider.
+            // TODO: check for cursor occurrences in nested objects
+            // Get the latest down or movement cursor occurrence.
+            while (c.occurrences[j]?.id === exports.movementType.UP &&
+                j > hitTimeBeforeIndex) {
+                --j;
+            }
+            if (object.object instanceof osuBase.Circle) {
+                // For circles, we only need to consider the actual press on the circle.
+                // Therefore, we need to get the latest down cursor occurrence instead.
+                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;
-                        }
+            }
+            // Theoretically there can only be 1 up occurrence, but this is a
+            // consideration if the user manually adds cursor occurrences.
+            if (c.occurrences[j]?.id === exports.movementType.UP) {
+                ++j;
+            }
+            // 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.
+            let nextSignificantOccurrenceIndex = j + 1;
+            while (c.occurrences[j] &&
+                c.occurrences[nextSignificantOccurrenceIndex] &&
+                c.occurrences[j].position.equals(c.occurrences[nextSignificantOccurrenceIndex].position)) {
+                ++nextSignificantOccurrenceIndex;
+            }
+            const nextSignificantOccurrence = c.occurrences[nextSignificantOccurrenceIndex];
+            const next = this.map.objects[index + 1];
+            if (nextSignificantOccurrence?.id === exports.movementType.MOVE && next) {
+                // Get the object's actual end position.
+                let actualEndPosition = object.object.stackedEndPosition;
+                if (object.object instanceof osuBase.Slider &&
+                    object.object.lazyEndPosition) {
+                    // For sliders, we take the closest distance between the lazy end position
+                    // and stacked end position towards the next significant cursor occurrence.
+                    // This assumes that the player takes the simpler movement.
+                    const lazyEndDistance = object.object.lazyEndPosition.getDistance(nextSignificantOccurrence.position);
+                    const actualEndDistance = object.object.stackedEndPosition.getDistance(nextSignificantOccurrence.position);
+                    if (lazyEndDistance < actualEndDistance) {
+                        actualEndPosition = object.object.lazyEndPosition;
                     }
                 }
+                // Get the movement vector towards the next cursor occurrence by subtracting
+                // the next cursor occurrence with the object's position.
+                const movementVec = nextSignificantOccurrence.position.subtract(actualEndPosition);
+                const currentToNext = next.object.stackedPosition.subtract(actualEndPosition);
+                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 (minDistance <= object.object.radius) {
-                cursorInformations.push({
-                    cursorIndex: i,
-                    hitTimeDiff: Math.abs(minHitTime - hitTime),
-                });
-            }
-        }
-        if (cursorInformations.length === 0) {
-            return -1;
+            cursorInformations.push({
+                // If the angle is fulfilled, we set the cursor index to the main cursor index.
+                cursorIndex: isAngleFulfilled ? -1 : i,
+                distanceDiff: distance,
+            });
         }
-        // Now we look at which cursor is closest to hit time
-        const minHitTimeDiff = Math.min(...cursorInformations.map((v) => {
-            return v.hitTimeDiff;
-        }));
-        return (cursorInformations.find((c) => c.hitTimeDiff === minHitTimeDiff)
-            ?.cursorIndex);
+        // 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) => v.distanceDiff));
+        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);
         });
+        // Preserve some values that aren't reasonable for them to be changed.
+        const preservedValues = this.map.objects.map((v) => {
+            return {
+                noteDensity: v.noteDensity,
+                rhythmStrain: v.rhythmStrain,
+                rhythmMultiplier: v.rhythmMultiplier,
+            };
+        });
         this.map.objects.length = 0;
         beatmaps.forEach((beatmap) => {
             if (!beatmap) {
@@ -1155,15 +1257,25 @@ 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.calculateAll();
+        this.map.objects.sort((a, b) => a.startTime - b.startTime);
+        // Reassign rhythm values before calculating.
+        for (let i = 0; i < this.map.objects.length; ++i) {
+            this.map.objects[i].noteDensity = preservedValues[i].noteDensity;
+            this.map.objects[i].rhythmStrain = preservedValues[i].rhythmStrain;
+            this.map.objects[i].rhythmMultiplier =
+                preservedValues[i].rhythmMultiplier;
+        }
+        // Do not include rhythm skill.
+        this.map.calculateAim();
+        this.map.calculateTap();
+        this.map.calculateFlashlight();
+        this.map.calculateVisual();
+        this.map.calculateTotal();
     }
 }
 
@@ -1404,42 +1516,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 +1831,7 @@ class ReplayObjectData {
 }
 
 exports.CursorData = CursorData;
+exports.CursorOccurrence = CursorOccurrence;
 exports.ReplayAnalyzer = ReplayAnalyzer;
 exports.ReplayData = ReplayData;
 exports.ReplayObjectData = ReplayObjectData;