@rian8337/osu-droid-replay-analyzer 2.0.0-alpha.3 → 2.0.0-alpha.32

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]));
+        }
     }
 }
 
@@ -327,7 +347,9 @@ class ThreeFingerChecker {
                 .includes(m.droidString)),
         }).calculate();
         this.hitWindow = new osuBase.DroidHitWindow(stats.od);
-        const strainNotes = map.objects.filter((v) => v.originalTapStrain >= ThreeFingerChecker.strainThreshold);
+        const strainNotes = map.objects.filter(
+        //@ts-expect-error: No overloads match, but this is fine.
+        (v) => v.originalTapStrain >= ThreeFingerChecker.strainThreshold);
         this.strainNoteCount = strainNotes.length;
     }
     /**
@@ -352,14 +374,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 +502,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 +599,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 +647,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 +741,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 +788,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(i);
                 }
             });
             const cursorAmounts = [];
@@ -791,13 +802,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,
                         });
                     }
                 }
@@ -846,9 +857,7 @@ class ThreeFingerChecker {
             // Sort by highest count; assume the order is 3rd, 4th, 5th, ... finger
             const validPresses = similarPresses
                 .filter((v) => v.count >= this.cursorDistancingCountThreshold)
-                .sort((a, b) => {
-                return b.count - a.count;
-            })
+                .sort((a, b) => b.count - a.count)
                 .slice(2);
             // Ignore cursor presses that are only 1 for now since they are very likely to be accidental
             if ((threeFingerRatio > this.threeFingerRatioThreshold &&
@@ -860,7 +869,10 @@ class ThreeFingerChecker {
                     1;
                 const strainFactor = Math.pow(objects
                     .slice(beatmapSection.firstObjectIndex, beatmapSection.lastObjectIndex)
-                    .reduce((acc, value) => acc +
+                    //@ts-expect-error: No overloads match, but this is fine.
+                    .reduce(
+                //@ts-expect-error: No overloads match, but this is fine.
+                (acc, value) => acc +
                     value.originalTapStrain /
                         ThreeFingerChecker.strainThreshold, 0), 0.75);
                 // We can ignore the first 3 (2 for drag) filled cursor instances
@@ -872,7 +884,7 @@ class ThreeFingerChecker {
                 const fingerFactor = threeFingerRatio > this.threeFingerRatioThreshold
                     ? threeFingerCursorAmounts.reduce((acc, value, index) => acc +
                         Math.pow(((index + 1) * value * objectCount) /
-                            this.strainNoteCount, 0.8), 1)
+                            this.strainNoteCount, 0.9), 1)
                     : Math.pow(validPresses.reduce((acc, value, index) => acc +
                         Math.pow(((index + 1) *
                             (value.count /
@@ -907,20 +919,36 @@ class ThreeFingerChecker {
  */
 class IndexedHitObject {
     /**
-     * The index of the cursor that hits the hitobject.
+     * The accepted index of the cursor that hits the hitobject.
+     */
+    acceptedCursorIndex;
+    /**
+     * The actual index of the cursor that hits the hitobject.
      */
-    cursorIndex;
+    actualCursorIndex;
+    /**
+     * The occurrence index of the cursor that hits the hitobject.
+     */
+    occurrenceIndex;
+    /**
+     * If this is a slider, whether the slider was cheesed.
+     */
+    sliderCheesed = false;
     /**
      * The underlying difficulty hitobject.
      */
     object;
     /**
      * @param object The underlying difficulty hitobject.
-     * @param cursorIndex The index of the cursor that hits the hitobject.
+     * @param acceptedCursorIndex The accepted index of the cursor that hits the hitobject.
+     * @param actualCursorIndex The actual index of the cursor that hits the hitobject.
+     * @param occurrenceIndex The occurrence index of the cursor that hits the hitobject.
      */
-    constructor(object, cursorIndex) {
+    constructor(object, acceptedCursorIndex, actualCursorIndex, occurrenceIndex) {
         this.object = object;
-        this.cursorIndex = cursorIndex;
+        this.acceptedCursorIndex = acceptedCursorIndex;
+        this.actualCursorIndex = actualCursorIndex;
+        this.occurrenceIndex = occurrenceIndex;
     }
 }
 
@@ -936,10 +964,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,177 +998,412 @@ class TwoHandChecker {
      * Checks if a beatmap is two-handed.
      */
     check() {
-        this.filterCursorInstances();
-        if (this.downMoveCursorInstances.filter((v) => v.size > 0).length <= 1) {
-            return false;
+        if (this.data.cursorMovement.filter((v) => v.occurrences.length > 0)
+            .length <= 1) {
+            return { is2Hand: false, cursorIndexes: [] };
         }
         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);
+        const indexes = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
+        for (const object of this.indexedHitObjects) {
+            ++indexes[object.acceptedCursorIndex];
         }
+        return {
+            is2Hand: indexes.filter((v) => v > 0).length !== 1,
+            cursorIndexes: this.indexedHitObjects.map((v) => v.acceptedCursorIndex),
+        };
     }
     /**
      * 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);
-            indexes.push(index);
-            this.indexedHitObjects.push(new IndexedHitObject(current, index));
+            const indexedHitObject = this.getIndexedHitObject(i, hitWindowOffset);
+            indexes.push(indexedHitObject.acceptedCursorIndex);
+            this.indexedHitObjects.push(indexedHitObject);
         }
-        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;
             }
             ++indexCounts[index];
         }
-        const mainCursorIndex = indexCounts.indexOf(Math.max(...indexCounts));
+        const mainCursorIndex = indexCounts.length > 0
+            ? indexCounts.indexOf(Math.max(...indexCounts))
+            : 0;
         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);
             }
         }
-        this.indexedHitObjects.forEach((indexedHitObject) => {
-            if (indexedHitObject.cursorIndex === -1 ||
-                ignoredCursorIndexes.includes(indexedHitObject.cursorIndex)) {
-                indexedHitObject.cursorIndex = mainCursorIndex;
+        // Add cursor presses that don't fulfill minimum cursor
+        // count to the farthest cursor index that isn't 0.
+        let defaultMinCursorCountIndex = this.data.cursorMovement.length - 1;
+        for (; defaultMinCursorCountIndex > 0; --defaultMinCursorCountIndex) {
+            if (indexCounts[defaultMinCursorCountIndex] >=
+                this.minCursorIndexCount &&
+                !ignoredCursorIndexes.includes(defaultMinCursorCountIndex)) {
+                break;
+            }
+        }
+        this.indexedHitObjects.forEach((indexedHitObject, i) => {
+            if (indexedHitObject.acceptedCursorIndex === -1 ||
+                indexedHitObject.actualCursorIndex === -1) {
+                indexedHitObject.acceptedCursorIndex = mainCursorIndex;
+                indexedHitObject.actualCursorIndex = mainCursorIndex;
+            }
+            if (ignoredCursorIndexes.includes(indexedHitObject.acceptedCursorIndex)) {
+                indexedHitObject.acceptedCursorIndex =
+                    defaultMinCursorCountIndex;
+            }
+            // 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.
+            if (indexedHitObject.object.object instanceof osuBase.Slider) {
+                indexedHitObject.sliderCheesed = this.checkSliderCheesing(indexedHitObject, this.data.hitObjectData[i], hitWindowOffset);
             }
         });
-        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.acceptedCursorIndex === 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) {
+    getIndexedHitObject(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;
+            return new IndexedHitObject(object, -1, -1, -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);
+        // 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) {
+        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 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 < minimumHitTime &&
+                    nextOccurrence?.id !== exports.movementType.MOVE) {
                     continue;
                 }
-                // 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.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;
+                }
+                if (occurrence.id === exports.movementType.UP) {
                     continue;
                 }
-                if (c.time[j - 1] > maximumHitTime) {
-                    break;
+                distance =
+                    object.object.stackedPosition.getDistance(cursorPosition);
+                if (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, 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 > object.object.radius) {
+                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: boolean = false;
+            // Aside of angles, we need to consider if the player dragged from the previous object to the current object.
+            let isDragged = false;
+            // 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: number = j + 1;
+            // while (
+            //     c.occurrences[j] &&
+            //     c.occurrences[nextSignificantOccurrenceIndex] &&
+            //     c.occurrences[j].position.equals(
+            //         c.occurrences[nextSignificantOccurrenceIndex].position
+            //     )
+            // ) {
+            //     ++nextSignificantOccurrenceIndex;
+            // }
+            // const nextSignificantOccurrence: CursorOccurrence =
+            //     c.occurrences[nextSignificantOccurrenceIndex];
+            // const next: DifficultyHitObject | RebalanceDifficultyHitObject =
+            //     this.map.objects[index + 1];
+            // Angle detection.
+            /* if (nextSignificantOccurrence?.id === movementType.MOVE && next) {
+                // Get the object's actual end position.
+                let actualEndPosition: Vector2 =
+                    object.object.stackedEndPosition;
+
+                if (
+                    object.object instanceof 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: number =
+                        object.object.lazyEndPosition.getDistance(
+                            nextSignificantOccurrence.position
+                        );
+                    const actualEndDistance: number =
+                        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: Vector2 =
+                    nextSignificantOccurrence.position.subtract(
+                        actualEndPosition
+                    );
+
+                const currentToNext: Vector2 =
+                    next.object.stackedPosition.subtract(actualEndPosition);
+
+                const dot: number = currentToNext.dot(movementVec);
+                const det: number =
+                    currentToNext.x * movementVec.y -
+                    currentToNext.y * movementVec.x;
+
+                const movementToNextAngle: number = Math.abs(
+                    Math.atan2(det, dot)
+                );
+
+                isAngleFulfilled = movementToNextAngle < Math.PI / 6;
+            } */
+            // Dragging detection.
+            let dragTimeThreshold = 0;
+            const prev = this.map.objects[index - 1];
+            if (prev) {
+                // The previous object might be a slider, so we need to get
+                // the hit data of it to get an accurate time threshold.
+                const prevData = this.data.hitObjectData[index - 1];
+                dragTimeThreshold = prev.object.startTime;
+                if (!(prev.object instanceof osuBase.Spinner)) {
+                    dragTimeThreshold += prevData.accuracy;
+                }
+                if (prev.object instanceof osuBase.Slider) {
+                    dragTimeThreshold = Math.max(dragTimeThreshold, prev.object.endTime);
+                }
             }
-            if (minDistance <= object.object.radius) {
-                cursorInformations.push({
-                    cursorIndex: i,
-                    hitTimeDiff: Math.abs(minHitTime - hitTime),
-                });
+            let occurrenceStartIndex = hitTimeAfterIndex;
+            while (c.occurrences[occurrenceStartIndex]?.time >=
+                dragTimeThreshold &&
+                occurrenceStartIndex > 0) {
+                --occurrenceStartIndex;
             }
+            // The above loop will make the start index before or right when
+            // the previous object was hit or ended, but we want the index after it.
+            ++occurrenceStartIndex;
+            const dragOccurrences = c.occurrences.slice(occurrenceStartIndex, hitTimeAfterIndex);
+            isDragged =
+                dragOccurrences.length > 0 &&
+                    // We only care when the cursor approaches the current object. It doesn't
+                    // matter whether the previous object was pressed or dragged.
+                    dragOccurrences
+                        .at(-1)
+                        .position.getDistance(object.object.stackedPosition) <=
+                        object.object.radius &&
+                    dragOccurrences.every((v) => v.id === exports.movementType.MOVE);
+            cursorInformations.push({
+                // If the angle is fulfilled or the player dragged,
+                // we set the cursor index to the main cursor index.
+                acceptedCursorIndex: /* isAngleFulfilled ||  */ isDragged
+                    ? -1
+                    : i,
+                actualCursorIndex: i,
+                occurrenceIndex: j,
+                distanceDiff: distance,
+            });
         }
-        if (cursorInformations.length === 0) {
-            return -1;
+        // 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));
+        const acceptedCursorInformation = cursorInformations.find((c) => c.distanceDiff === minDistanceDiff);
+        return new IndexedHitObject(object, acceptedCursorInformation?.acceptedCursorIndex ?? -1, acceptedCursorInformation?.actualCursorIndex ?? -1, acceptedCursorInformation?.occurrenceIndex ?? -1);
+    }
+    /**
+     * Checks whether a slider was cheesed.
+     *
+     * This is done by checking if a cursor follows a slider all the way to its end position.
+     *
+     * @param indexedHitObject The indexed slider.
+     * @param hitData The hit data of the slider.
+     * @param actualCursorIndex The actual cursor index that hit the slider.
+     * @param hitWindowOffset The offset that was calculated by `getHitWindowOffset()`
+     * @returns Whether the slider was cheesed.
+     */
+    checkSliderCheesing(indexedHitObject, hitData, hitWindowOffset) {
+        if (!(indexedHitObject.object.object instanceof osuBase.Slider) ||
+            hitData.result === exports.hitResult.RESULT_0) {
+            return false;
         }
-        // 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);
+        let cursorLoopIndex = Math.max(0, indexedHitObject.occurrenceIndex);
+        const c = this.data.cursorMovement[indexedHitObject.actualCursorIndex];
+        const acceptableRadius = indexedHitObject.object.object.radius * 2.4;
+        for (let i = 1; i < indexedHitObject.object.object.nestedHitObjects.length; ++i) {
+            const tickWasHit = hitData.tickset[i - 1];
+            if (!tickWasHit) {
+                continue;
+            }
+            const object = indexedHitObject.object.object.nestedHitObjects[i];
+            let j = cursorLoopIndex;
+            let cursorHitTick = false;
+            for (j; j < c.occurrences.length; ++j) {
+                if (c.occurrences[j].time <
+                    object.startTime - hitWindowOffset) {
+                    continue;
+                }
+                if (c.occurrences[j].time >
+                    object.startTime + hitWindowOffset) {
+                    break;
+                }
+                if (c.occurrences[j].position.getDistance(object.stackedPosition) <= acceptableRadius) {
+                    cursorHitTick = true;
+                    break;
+                }
+            }
+            if (!cursorHitTick) {
+                return true;
+            }
+            cursorLoopIndex = j;
+        }
+        return false;
     }
     /**
      * 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]) {
+            if (!beatmaps[o.acceptedCursorIndex]) {
                 const map = osuBase.Utils.deepCopy(this.map.map);
-                beatmaps[o.cursorIndex] = map;
+                map.hitObjects.clear();
+                beatmaps[o.acceptedCursorIndex] = map;
             }
-            beatmaps[o.cursorIndex].hitObjects.add(o.object.object);
+            beatmaps[o.acceptedCursorIndex].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,
+                overlappingFactor: v.overlappingFactor,
+                rhythmStrain: v.rhythmStrain,
+                rhythmMultiplier: v.rhythmMultiplier,
+            };
         });
         this.map.objects.length = 0;
         beatmaps.forEach((beatmap) => {
@@ -1155,15 +1414,32 @@ 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 preserved values before calculating.
+        for (let i = 0; i < this.map.objects.length; ++i) {
+            const diffObject = this.map.objects[i];
+            const indexedHitObject = this.indexedHitObjects[i];
+            const preservedValue = preservedValues[i];
+            diffObject.noteDensity = preservedValue.noteDensity;
+            diffObject.overlappingFactor = preservedValue.overlappingFactor;
+            diffObject.rhythmStrain = preservedValue.rhythmStrain;
+            diffObject.rhythmMultiplier = preservedValue.rhythmMultiplier;
+            // Set slider travel distance to 0 if the slider was cheesed.
+            if (indexedHitObject.sliderCheesed) {
+                diffObject.travelDistance = 0;
+            }
+        }
+        // Do not include rhythm skill.
+        this.map.calculateAim();
+        this.map.calculateTap();
+        this.map.calculateFlashlight();
+        this.map.calculateVisual();
+        this.map.calculateTotal();
     }
 }
 
@@ -1219,6 +1495,12 @@ class ReplayAnalyzer {
      * Whether this replay has been checked against 2 hand usage.
      */
     hasBeenCheckedFor2Hand = false;
+    /**
+     * The cursor indexes at which each object was hit.
+     *
+     * This is filled after 2 hand usage has been checked.
+     */
+    twoHandCursorIndexes = [];
     // Sizes of primitive data types in Java (in bytes)
     BYTE_LENGTH = 1;
     SHORT_LENGTH = 2;
@@ -1404,42 +1686,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;
@@ -1685,7 +1966,9 @@ class ReplayAnalyzer {
             return;
         }
         const twoHandChecker = new TwoHandChecker(this.map, this.data);
-        this.is2Hand = twoHandChecker.check();
+        const result = twoHandChecker.check();
+        this.is2Hand = result.is2Hand;
+        this.twoHandCursorIndexes = result.cursorIndexes;
         this.hasBeenCheckedFor2Hand = true;
     }
 }
@@ -1720,6 +2003,7 @@ class ReplayObjectData {
 }
 
 exports.CursorData = CursorData;
+exports.CursorOccurrence = CursorOccurrence;
 exports.ReplayAnalyzer = ReplayAnalyzer;
 exports.ReplayData = ReplayData;
 exports.ReplayObjectData = ReplayObjectData;