@rian8337/osu-droid-replay-analyzer 3.0.0-beta.26 → 3.0.0-beta.30

package/dist/index.js

@@ -128,10 +128,7 @@ class CursorOccurrenceGroup {
      * The time at which this cursor occurrence group ends.
      */
     get endTime() {
-        if (this._up) {
-            return this._up.time;
-        }
-        return this._moves.at(-1)?.time ?? this._down.time;
+        return this._up?.time ?? this._moves.at(-1)?.time ?? this._down.time;
     }
     /**
      * All cursor occurrences in this group.
@@ -561,13 +558,10 @@ class ThreeFingerChecker {
         const stats = new osuBase.MapStats({
             od: this.calculator.beatmap.difficulty.od,
             mods: this.calculator.mods.filter((m) => m.isApplicableToDroid() &&
-                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym) &&
-                !(m instanceof osuBase.ModPrecise)),
+                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
         }).calculate();
         this.hitWindow = new osuBase.DroidHitWindow(stats.od);
-        const strainNotes = calculator.objects.filter(
-        //@ts-expect-error: No overloads match, but this is fine.
-        (v) => v.originalTapStrain >= ThreeFingerChecker.strainThreshold);
+        const strainNotes = calculator.objects.filter((v) => v.originalTapStrain >= ThreeFingerChecker.strainThreshold);
         this.strainNoteCount = strainNotes.length;
     }
     /**
@@ -1130,17 +1124,16 @@ class ThreeFingerChecker {
  */
 class IndexedHitObject {
     /**
-     * The accepted index of the cursor that hits the hitobject.
-     */
-    acceptedCursorIndex;
-    /**
-     * The actual index of the cursor that hits the hitobject.
+     * The cursor index that hits the hitobject.
+     *
+     * If -1, the detection was unable to find any cursor that attempted to hit
+     * the hitobject or it did not meet the criteria for detection.
      */
-    actualCursorIndex;
+    cursorIndex;
     /**
-     * The occurrence index of the cursor that hits the hitobject.
+     * The angle of the movement of the cursor towards the next hitobject.
      */
-    occurrenceIndex;
+    angle;
     /**
      * If this is a slider, whether the slider was cheesed.
      */
@@ -1149,17 +1142,21 @@ class IndexedHitObject {
      * The underlying difficulty hitobject.
      */
     object;
+    /**
+     * Whether the hitobject was most likely two-handed.
+     */
+    get is2Handed() {
+        return this.angle !== null && this.angle >= Math.PI / 6;
+    }
     /**
      * @param object The underlying difficulty 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.
+     * @param cursorIndex The cursor index that moves towards the hitobject.
+     * @param angle The angle of the movement of the cursor that moves towards the hitobject.
      */
-    constructor(object, acceptedCursorIndex, actualCursorIndex, occurrenceIndex) {
+    constructor(object, cursorIndex, angle) {
         this.object = object;
-        this.acceptedCursorIndex = acceptedCursorIndex;
-        this.actualCursorIndex = actualCursorIndex;
-        this.occurrenceIndex = occurrenceIndex;
+        this.cursorIndex = cursorIndex;
+        this.angle = angle;
     }
 }
 
@@ -1184,19 +1181,9 @@ class TwoHandChecker {
      */
     hitWindow;
     /**
-     * The minimum count of a cursor index occurrence to be valid.
-     *
-     * This is used to prevent excessive penalty by splitting the beatmap into
-     * those that do not worth any strain.
+     * The 50 osu!droid hit window of the analyzed beatmap.
      */
-    minCursorIndexCount = 5;
-    /**
-     * A cursor occurrence nested array containing all cursor occurrences.
-     *
-     * Each index represents the cursor index.
-     */
-    // TODO: replace with group at some point
-    allCursorOccurrences = [];
+    hitWindow50;
     /**
      * @param calculator The difficulty calculator to analyze.
      * @param data The data of the replay.
@@ -1204,14 +1191,13 @@ class TwoHandChecker {
     constructor(calculator, data) {
         this.calculator = calculator;
         this.data = data;
-        this.allCursorOccurrences = data.cursorMovement.map((v) => v.allOccurrences);
         const stats = new osuBase.MapStats({
             od: this.calculator.beatmap.difficulty.od,
             mods: this.calculator.mods.filter((m) => m.isApplicableToDroid() &&
-                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym) &&
-                !(m instanceof osuBase.ModPrecise)),
+                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
         }).calculate();
         this.hitWindow = new osuBase.DroidHitWindow(stats.od);
+        this.hitWindow50 = this.hitWindow.hitWindowFor50(calculator.mods.some((m) => m instanceof osuBase.ModPrecise));
     }
     /**
      * Checks if a beatmap is two-handed.
@@ -1222,337 +1208,549 @@ class TwoHandChecker {
         }
         this.indexHitObjects();
         this.applyPenalty();
-        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),
-        };
+        return { is2Hand: false, cursorIndexes: [] };
     }
     /**
      * Converts hitobjects into indexed hit objects.
      */
     indexHitObjects() {
-        const hitWindowOffset = this.getHitWindowOffset();
         const indexes = [];
         for (let i = 0; i < this.calculator.objects.length; ++i) {
-            const indexedHitObject = this.getIndexedHitObject(i, hitWindowOffset);
-            indexes.push(indexedHitObject.acceptedCursorIndex);
+            const indexedHitObject = this.getIndexedHitObject(i);
+            indexedHitObject.sliderCheesed = this.checkSliderCheesing(indexedHitObject, this.data.hitObjectData[i]);
+            indexes.push(indexedHitObject.cursorIndex);
             this.indexedHitObjects.push(indexedHitObject);
         }
-        const indexCounts = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
-        for (const index of indexes) {
-            if (index === -1) {
-                continue;
-            }
-            ++indexCounts[index];
-        }
-        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 &&
-                i !== mainCursorIndex) {
-                ignoredCursorIndexes.push(i);
-            }
-        }
-        // 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);
-            }
-        });
+        console.log(this.indexedHitObjects.filter((v) => v.cursorIndex !== -1).length +
+            1, "indexes found,", this.indexedHitObjects.filter((v) => v.cursorIndex === -1).length -
+            1, "not found,", this.indexedHitObjects.filter((v) => v.is2Handed).length, "2 handed,", this.indexedHitObjects.filter((v) => !v.is2Handed).length, "not 2 handed");
         for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            console.log("Index", i, "count:", this.indexedHitObjects.filter((v) => v.acceptedCursorIndex === i).length);
-        }
+            console.log("Index", i, "count:", this.indexedHitObjects.filter((v) => v.cursorIndex === i).length);
+        }
+        // TODO: solve -1 cursor indexes
+        console.table(this.indexedHitObjects
+            .filter((v) => 
+        // v.cursorIndex === -1 &&
+        // v.object.aimStrainWithSliders > 200 &&
+        v.object.deltaTime > 75 &&
+            v.is2Handed)
+            .map((v) => {
+            return {
+                startTime: v.object.object.startTime,
+                type: v.object.object.typeStr(),
+                strain: v.object.aimStrainWithSliders,
+                hitAngle: v.angle !== null
+                    ? osuBase.MathUtils.radiansToDegrees(v.angle)
+                    : null,
+                objectAngle: v.object.angle !== null
+                    ? osuBase.MathUtils.radiansToDegrees(v.object.angle)
+                    : null,
+                cursorIndex: v.cursorIndex,
+            };
+        }));
     }
     /**
-     * Gets the hit window offset to be applied to `getCursorIndex`.
+     * Gets the cursor index that hits the given object.
+     *
+     * @param objectIndex The index of the object to check.
+     * @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.
      */
-    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.occurrenceGroups.length; ++j) {
-                const group = c.occurrenceGroups[j];
-                const previousGroup = c.occurrenceGroups[j - 1];
-                if (group.startTime <
-                    this.calculator.beatmap.hitObjects.objects[0].startTime -
-                        this.hitWindow.hitWindowFor50()) {
-                    continue;
-                }
-                const deltaTime = group.startTime - previousGroup.endTime;
-                if (deltaTime > 0) {
-                    deltaTimes.push(deltaTime);
+    getIndexedHitObject(objectIndex) {
+        const diffObject = this.calculator.objects[objectIndex];
+        const { object } = diffObject;
+        // We don't care about the first object and spinners.
+        if (objectIndex === 0 || object instanceof osuBase.Spinner) {
+            return new IndexedHitObject(diffObject, -1, null);
+        }
+        // We don't care if the aim strain is too low.
+        if (diffObject.aimStrainWithSliders < 200) {
+            return new IndexedHitObject(diffObject, -1, null);
+        }
+        const prevObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
+        const prevObjectData = this.data.hitObjectData[objectIndex - 1];
+        if (prevObject instanceof osuBase.Spinner ||
+            prevObjectData.result === exports.HitResult.miss) {
+            return new IndexedHitObject(diffObject, -1, null);
+        }
+        const objectStartPosition = object.getStackedPosition(osuBase.Modes.droid);
+        let prevObjectEndPosition = prevObject.getStackedEndPosition(osuBase.Modes.droid);
+        if (prevObject instanceof osuBase.Slider) {
+            if (prevObject.lazyTravelDistance > 0) {
+                const lazyEndMovement = objectStartPosition.subtract(prevObject.lazyEndPosition);
+                const actualEndMovement = objectStartPosition.subtract(prevObjectEndPosition);
+                if (lazyEndMovement.length < actualEndMovement.length) {
+                    prevObjectEndPosition = prevObject.lazyEndPosition;
                 }
             }
+            else {
+                prevObjectEndPosition = prevObject.getStackedPosition(osuBase.Modes.droid);
+            }
         }
-        return Math.min(...deltaTimes);
+        const prevToCurrentMovement = object
+            .getStackedPosition(osuBase.Modes.droid)
+            .subtract(prevObjectEndPosition);
+        // Don't consider objects that are too close to each other.
+        if (prevToCurrentMovement.length <= object.getRadius(osuBase.Modes.droid)) {
+            return new IndexedHitObject(diffObject, -1, null);
+        }
+        // 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 current
+        // object is sufficient enough to be two-handed. This is done by first gathering info about two cursor positions:
+        // 1. The cursor position at the end of the previous object
+        // 2. The cursor position that presses the current object
+        // and then get the movement vector between both positions, then see if the cursor movement after the previous object
+        // was pressed produces an angle that is acute enough with respect to the aforementioned movement vector.
+        const objectInformation = this.getCursorPositionForObjectStart(objectIndex);
+        const prevObjectInformation = this.getCursorPositionForObjectEnd(objectIndex - 1);
+        if (prevObjectInformation.position.x === Number.POSITIVE_INFINITY) {
+            return new IndexedHitObject(diffObject, -1, null);
+        }
+        const cursorData = this.data.cursorMovement[prevObjectInformation.cursorIndex];
+        // There can be multiple angles to which the cursor moves towards the next object.
+        // For this, we take the smallest angle.
+        let finalAngle = Number.POSITIVE_INFINITY;
+        const cursorGroup = cursorData.occurrenceGroups[prevObjectInformation.groupIndex];
+        const cursors = cursorGroup.allOccurrences;
+        const prevToCurrentCursorMovement = objectInformation.position.subtract(prevObjectInformation.position);
+        for (let i = prevObjectInformation.cursorGroupIndex + 1; i < cursors.length; ++i) {
+            const cursor = cursors[i];
+            const prevCursor = cursors[i - 1];
+            if (cursor.position.equals(prevCursor.position)) {
+                continue;
+            }
+            if (cursor.id === exports.MovementType.up) {
+                break;
+            }
+            const currentMovement = cursor.position.subtract(prevCursor.position);
+            const dot = prevToCurrentCursorMovement.dot(currentMovement);
+            const det = prevToCurrentCursorMovement.x * currentMovement.y -
+                prevToCurrentCursorMovement.y * currentMovement.x;
+            const movementAngle = Math.abs(Math.atan2(det, dot));
+            finalAngle = Math.min(finalAngle, movementAngle);
+        }
+        return new IndexedHitObject(diffObject, Number.isFinite(finalAngle)
+            ? prevObjectInformation.cursorIndex
+            : -1, Number.isFinite(finalAngle) ? finalAngle : null);
+        // let checkingTime: number = prevObject.endTime;
+        // if (prevObject instanceof Circle) {
+        //     checkingTime += prevObjectData.accuracy;
+        // } else if (prevDiffObject.travelDistance === 0) {
+        //     // If the slider doesn't have any travel distance, use the start time as the checking point.
+        //     checkingTime = prevObject.startTime;
+        //     if (prevObjectData.accuracy !== Math.floor(this.hitWindow50) + 13) {
+        //         checkingTime += prevObjectData.accuracy;
+        //     }
+        // }
+        // let cursorTimeLimit: number = object.startTime;
+        // if (object instanceof Circle) {
+        //     cursorTimeLimit += objectData.accuracy;
+        // } else if (object instanceof Slider) {
+        //     if (objectData.accuracy !== Math.floor(this.hitWindow50) + 13) {
+        //         cursorTimeLimit += objectData.accuracy;
+        //     } else {
+        //         cursorTimeLimit += this.hitWindow50;
+        //     }
+        // }
+        // let hitWindow: number = this.hitWindow50;
+        // const isPrecise: boolean = this.data.convertedMods.some(
+        //     (m) => m instanceof ModPrecise
+        // );
+        // // For sliders, set the hit window to as lenient as possible.
+        // if (object instanceof Circle) {
+        //     switch (objectData.result) {
+        //         case HitResult.great:
+        //             hitWindow = this.hitWindow.hitWindowFor300(isPrecise);
+        //             break;
+        //         case HitResult.good:
+        //             hitWindow = this.hitWindow.hitWindowFor100(isPrecise);
+        //             break;
+        //     }
+        // }
+        // // There can be multiple angles to which every cursor moves towards the next object.
+        // // For this, we take the smallest angle from a cursor.
+        // const finalAngles: number[] = Utils.initializeArray(
+        //     this.data.cursorMovement.length,
+        //     Number.POSITIVE_INFINITY
+        // );
+        // for (
+        //     let i = prevObjectInformation.cursorIndex;
+        //     i < this.data.cursorMovement.length;
+        //     ++i
+        // ) {
+        // }
+        // for (const cursor of this.data.cursorMovement) {
+        //     // TODO: use same method for getCursorPositionForObject
+        //     const cursorGroup: CursorOccurrenceGroup | undefined =
+        //         cursor.occurrenceGroups.find((v) => v.isActiveAt(checkingTime));
+        //     if (!cursorGroup) {
+        //         continue;
+        //     }
+        //     const cursors: CursorOccurrence[] = cursorGroup.allOccurrences;
+        //     // This is the best approximation we can come up with, which is the cursor position
+        //     // at the previous object's end time.
+        //     let cursorIndex: number = cursors.findIndex(
+        //         (v) => v.time >= checkingTime
+        //     );
+        //     const endTimeCursor: CursorOccurrence = cursors[cursorIndex];
+        //     if (endTimeCursor.id === MovementType.up) {
+        //         continue;
+        //     }
+        //     let actualEndCursorPosition: Vector2 = endTimeCursor.position;
+        //     if (endTimeCursor.id === MovementType.move) {
+        //         // Interpolate end cursor up to the point of checking time.
+        //         const prevCursor: CursorOccurrence = cursors[cursorIndex - 1];
+        //         const t: number =
+        //             (checkingTime - prevCursor.time) /
+        //             (endTimeCursor.time - prevCursor.time);
+        //         actualEndCursorPosition = new Vector2(
+        //             Interpolation.lerp(
+        //                 prevCursor.position.x,
+        //                 endTimeCursor.position.x,
+        //                 t
+        //             ),
+        //             Interpolation.lerp(
+        //                 prevCursor.position.y,
+        //                 endTimeCursor.position.y,
+        //                 t
+        //             )
+        //         );
+        //     }
+        //     // There can be multiple angles to which the cursor moves towards the next object.
+        //     // For this, we take the smallest angle.
+        //     let finalAngle: number = Number.POSITIVE_INFINITY;
+        //     // Start the loop at index + 1 so that the loop considers the next cursor as opposed to
+        //     // the assigned cursor above. Don't do it if the next cursor is an up occurrence, though.
+        //     if (
+        //         cursorIndex === 0 ||
+        //         (cursorIndex < cursors.length - 2 &&
+        //             !cursors[cursorIndex + 1].position.equals(
+        //                 endTimeCursor.position
+        //             ))
+        //     ) {
+        //         ++cursorIndex;
+        //     }
+        //     const endCursorToCurrentMovement: Vector2 =
+        //         objectStartPosition.subtract(actualEndCursorPosition);
+        //     for (; cursorIndex < cursors.length; ++cursorIndex) {
+        //         const cursor: CursorOccurrence = cursors[cursorIndex];
+        //         const prevCursor: CursorOccurrence = cursors[cursorIndex - 1];
+        //         if (
+        //             cursor.id === MovementType.up ||
+        //             prevCursor.time >= cursorTimeLimit
+        //         ) {
+        //             break;
+        //         }
+        //         // Only consider occurrences that actually move from one place to another.
+        //         if (cursor.position.equals(prevCursor.position)) {
+        //             continue;
+        //         }
+        //         const distance: number = cursor.position.getDistance(
+        //             actualEndCursorPosition
+        //         );
+        //         if (distance > 1.5 * object.getRadius(Modes.droid)) {
+        //             continue;
+        //         }
+        //         const currentMovement: Vector2 = cursor.position.subtract(
+        //             prevCursor.position
+        //         );
+        //         const dot: number = currentMovement.dot(
+        //             endCursorToCurrentMovement
+        //         );
+        //         const det: number =
+        //             currentMovement.x * endCursorToCurrentMovement.y -
+        //             currentMovement.y * endCursorToCurrentMovement.x;
+        //         const movementAngle: number = Math.abs(Math.atan2(det, dot));
+        //         finalAngle = Math.min(finalAngle, movementAngle);
+        //     }
+        //     if (
+        //         finalAngle === Number.POSITIVE_INFINITY &&
+        //         (finalAngles.length === 0 ||
+        //             finalAngles.every((v) => v === Number.POSITIVE_INFINITY))
+        //     ) {
+        //         // Special case where drag occurrences are in the same spot as the press.
+        //         const { down, moves } = cursorGroup;
+        //         if (
+        //             // Don't consider this if the press occurrence does not hit the object.
+        //             down.position.getDistance(prevObjectEndPosition) <=
+        //                 object.getRadius(Modes.droid) &&
+        //             moves.every((v) => v.position.equals(down.position))
+        //         ) {
+        //             finalAngle = 0;
+        //         }
+        //     }
+        //     finalAngles.push(finalAngle);
+        // }
+        // const smallestAngle: number = Math.min(...finalAngles);
+        // const finalIndex: number = finalAngles.findIndex(
+        //     (v) => v === smallestAngle
+        // );
+        // return new IndexedHitObject(
+        //     diffObject,
+        //     Number.isFinite(smallestAngle) ? finalIndex : -1,
+        //     Number.isFinite(smallestAngle) ? smallestAngle : null
+        // );
     }
     /**
-     * Gets the cursor index that hits the given object.
+     * Gets the position of the cursor that presses an 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.
-     */
-    getIndexedHitObject(index, hitWindowOffset) {
-        const object = this.calculator.objects[index];
-        const data = this.data.hitObjectData[index];
-        if (object.object instanceof osuBase.Spinner ||
-            data.result === exports.HitResult.miss) {
-            return new IndexedHitObject(object, -1, -1, -1);
+     * @param objectIndex THe index of the object.
+     * @returns The position of the cursor that presses the object.
+     */
+    getCursorPositionForObjectStart(objectIndex) {
+        const object = this.calculator.beatmap.hitObjects.objects[objectIndex];
+        const data = this.data.hitObjectData[objectIndex];
+        const objectPosition = object.getStackedPosition(osuBase.Modes.droid);
+        if (object instanceof osuBase.Spinner) {
+            return {
+                position: objectPosition,
+                cursorIndex: 0,
+                groupIndex: Number.POSITIVE_INFINITY,
+                cursorGroupIndex: Number.POSITIVE_INFINITY,
+                cursorTime: object.startTime,
+            };
         }
+        const radius = object.getRadius(osuBase.Modes.droid);
+        let hitWindow = this.hitWindow50;
         const isPrecise = this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise);
-        // For sliders, automatically set hit window to be as lenient as possible.
-        let hitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
-        if (!(object.object instanceof osuBase.Slider)) {
+        // For sliders, set the hit window to as lenient as possible.
+        if (object instanceof osuBase.Circle) {
             switch (data.result) {
                 case exports.HitResult.great:
-                    hitWindowLength = this.hitWindow.hitWindowFor300(isPrecise);
+                    hitWindow = this.hitWindow.hitWindowFor300(isPrecise);
                     break;
                 case exports.HitResult.good:
-                    hitWindowLength = this.hitWindow.hitWindowFor100(isPrecise);
+                    hitWindow = this.hitWindow.hitWindowFor100(isPrecise);
                     break;
             }
         }
-        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.allCursorOccurrences.length; ++i) {
-            const c = this.allCursorOccurrences[i];
-            if (c.length === 0) {
-                continue;
-            }
-            let hitTimeBeforeIndex = osuBase.MathUtils.clamp(c.findIndex((v) => v.time >= minimumHitTime), 1, c.length - 1) - 1;
-            let hitTimeAfterIndex = c.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.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[hitTimeBeforeIndex]?.time ===
-                c[hitTimeBeforeIndex - 1]?.time &&
-                hitTimeBeforeIndex > 0) {
-                --hitTimeBeforeIndex;
+        // TODO: what to do for head sliderbreaks?
+        let nearestPosition = new osuBase.Vector2(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+        let nearestCursorIndex = 0;
+        let nearestGroupIndex = 0;
+        let nearestCursorGroupIndex = 0;
+        let nearestCursorTime = 0;
+        const minimumActiveTime = object.startTime - hitWindow;
+        const maximumActiveTime = object.startTime + hitWindow;
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            if (nearestPosition.getDistance(objectPosition) <= radius) {
+                break;
             }
-            // 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[j];
-                const nextOccurrence = c[j + 1];
-                const cursorPosition = occurrence.position;
-                if (occurrence.time < minimumHitTime &&
-                    nextOccurrence?.id !== exports.MovementType.move) {
-                    continue;
-                }
-                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
-                            .getStackedPosition(osuBase.Modes.droid)
-                            .getDistance(cursorPosition));
-                    }
+            const cursorData = this.data.cursorMovement[i];
+            for (let j = 0; j < cursorData.occurrenceGroups.length; ++j) {
+                if (nearestPosition.getDistance(objectPosition) <= radius) {
                     break;
                 }
-                if (occurrence.id === exports.MovementType.up) {
+                const cursorGroup = cursorData.occurrenceGroups[j];
+                if (cursorGroup.endTime < minimumActiveTime) {
                     continue;
                 }
-                distance = object.object
-                    .getStackedPosition(osuBase.Modes.droid)
-                    .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
-                            .getStackedPosition(osuBase.Modes.droid)
-                            .getDistance(cursorPosition.add(displacement.scale(progress)));
+                if (cursorGroup.startTime > maximumActiveTime) {
+                    break;
+                }
+                // Validate the down press first.
+                const { down } = cursorGroup;
+                if (down.position.getDistance(objectPosition) <= radius &&
+                    Math.abs(down.time - object.startTime) <= hitWindow) {
+                    if (objectIndex > 0) {
+                        const prevObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
+                        if (down.time > prevObject.endTime) {
+                            return {
+                                position: down.position,
+                                cursorIndex: i,
+                                groupIndex: j,
+                                cursorGroupIndex: 0,
+                                cursorTime: down.time,
+                            };
+                        }
+                    }
+                    else {
+                        return {
+                            position: down.position,
+                            cursorIndex: i,
+                            groupIndex: j,
+                            cursorGroupIndex: 0,
+                            cursorTime: down.time,
+                        };
                     }
                 }
-            }
-            if (distance > object.object.getRadius(osuBase.Modes.droid)) {
-                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[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[j]?.id !== exports.MovementType.down &&
-                    j > hitTimeBeforeIndex) {
-                    --j;
+                const cursors = cursorGroup.allOccurrences;
+                for (let k = 1; k < cursors.length; ++k) {
+                    const cursor = cursors[k];
+                    const prevCursor = cursors[k - 1];
+                    if (cursor.time < minimumActiveTime) {
+                        continue;
+                    }
+                    if (prevCursor.time > maximumActiveTime) {
+                        break;
+                    }
+                    let cursorPosition;
+                    if (cursor.id === exports.MovementType.up) {
+                        cursorPosition = prevCursor.position;
+                        const distance = cursorPosition.getDistance(objectPosition);
+                        if (distance <
+                            nearestPosition.getDistance(objectPosition)) {
+                            nearestPosition = cursorPosition;
+                            nearestCursorIndex = i;
+                            nearestGroupIndex = j;
+                            nearestCursorGroupIndex = k;
+                            nearestCursorTime = prevCursor.time;
+                        }
+                    }
+                    else {
+                        // Check for cursor presses inbetween occurrences.
+                        for (let k = 0; k < this.data.cursorMovement.length; ++k) {
+                            // Skip the current cursor index.
+                            if (k === i) {
+                                continue;
+                            }
+                            const cursorGroup = this.data.cursorMovement[k].occurrenceGroups.find((v) => v.down.time >= prevCursor.time &&
+                                v.down.time <= cursor.time);
+                            if (!cursorGroup) {
+                                continue;
+                            }
+                            const t = (cursorGroup.down.time - prevCursor.time) /
+                                (cursor.time - prevCursor.time);
+                            cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
+                            const distance = cursorPosition.getDistance(objectPosition);
+                            if (distance <
+                                nearestPosition.getDistance(objectPosition)) {
+                                nearestPosition = cursorPosition;
+                                nearestCursorIndex = i;
+                                nearestGroupIndex = j;
+                                nearestCursorGroupIndex = k;
+                                nearestCursorTime = cursorGroup.down.time;
+                            }
+                            if (distance <= radius) {
+                                break;
+                            }
+                        }
+                    }
+                    if (nearestPosition.getDistance(objectPosition) <= radius) {
+                        break;
+                    }
                 }
             }
-            // Theoretically there can only be 1 up occurrence, but this is a
-            // consideration if the user manually adds cursor occurrences.
-            if (c[j]?.id === exports.MovementType.up) {
-                ++j;
+        }
+        if (nearestPosition.getDistance(objectPosition) ===
+            Number.POSITIVE_INFINITY) {
+            return {
+                position: nearestPosition,
+                cursorIndex: Number.POSITIVE_INFINITY,
+                groupIndex: Number.POSITIVE_INFINITY,
+                cursorGroupIndex: Number.POSITIVE_INFINITY,
+                cursorTime: object.startTime,
+            };
+        }
+        return {
+            position: nearestPosition,
+            cursorIndex: nearestCursorIndex,
+            groupIndex: nearestGroupIndex,
+            cursorGroupIndex: nearestCursorGroupIndex,
+            cursorTime: nearestCursorTime,
+        };
+    }
+    /**
+     * Gets the position of the cursor that at an object's end position.
+     *
+     * @param objectIndex THe index of the object.
+     * @returns The position of the cursor at the object's end position.
+     */
+    getCursorPositionForObjectEnd(objectIndex) {
+        const object = this.calculator.beatmap.hitObjects.objects[objectIndex];
+        if (!(object instanceof osuBase.Slider)) {
+            return this.getCursorPositionForObjectStart(objectIndex);
+        }
+        const nextObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
+        let objectEndPosition = object.getStackedEndPosition(osuBase.Modes.droid);
+        if (object.lazyTravelDistance > 0 && nextObject) {
+            const nextStartPosition = nextObject.getStackedPosition(osuBase.Modes.droid);
+            const lazyEndMovement = nextStartPosition.subtract(object.lazyEndPosition);
+            const actualEndMovement = nextStartPosition.subtract(objectEndPosition);
+            if (lazyEndMovement.length < actualEndMovement.length) {
+                objectEndPosition = object.lazyEndPosition;
             }
-            // 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[j] &&
-            //     c[nextSignificantOccurrenceIndex] &&
-            //     c[j].position.equals(
-            //         c[nextSignificantOccurrenceIndex].position
-            //     )
-            // ) {
-            //     ++nextSignificantOccurrenceIndex;
-            // }
-            // const nextSignificantOccurrence: CursorOccurrence =
-            //     c[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;
-                    }
+        }
+        else {
+            objectEndPosition = object.getStackedPosition(osuBase.Modes.droid);
+        }
+        let nearestPosition = new osuBase.Vector2(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+        let nearestCursorIndex = 0;
+        let nearestGroupIndex = 0;
+        let nearestCursorGroupIndex = 0;
+        let nearestCursorTime = 0;
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const cursorData = this.data.cursorMovement[i];
+            for (let j = 0; j < cursorData.occurrenceGroups.length; ++j) {
+                const cursorGroup = cursorData.occurrenceGroups[j];
+                if (cursorGroup.endTime < object.startTime) {
+                    continue;
                 }
-
-                // 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.getStackedPosition(Modes.droid).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.calculator.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 (cursorGroup.startTime > object.endTime) {
+                    break;
                 }
-                if (prev.object instanceof osuBase.Slider) {
-                    dragTimeThreshold = Math.max(dragTimeThreshold, prev.object.endTime);
+                const cursors = cursorGroup.allOccurrences;
+                for (let k = 0; k < cursors.length; ++k) {
+                    const cursor = cursors[k];
+                    let cursorPosition;
+                    switch (cursor.id) {
+                        case exports.MovementType.down:
+                            cursorPosition = cursor.position;
+                            break;
+                        case exports.MovementType.up: {
+                            const prevCursor = cursors[k - 1];
+                            cursorPosition = prevCursor.position;
+                            break;
+                        }
+                        case exports.MovementType.move: {
+                            const prevCursor = cursors[k - 1];
+                            const t = osuBase.MathUtils.clamp((object.endTime - prevCursor.time) /
+                                (cursor.time - prevCursor.time), 0, 1);
+                            cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
+                            break;
+                        }
+                    }
+                    if (cursorPosition.getDistance(objectEndPosition) <
+                        nearestPosition.getDistance(objectEndPosition)) {
+                        nearestPosition = cursorPosition;
+                        nearestCursorIndex = i;
+                        nearestGroupIndex = j;
+                        switch (cursor.id) {
+                            case exports.MovementType.down:
+                                nearestCursorGroupIndex = k;
+                                nearestCursorTime = cursor.time;
+                                break;
+                            case exports.MovementType.up:
+                                nearestCursorGroupIndex = k - 1;
+                                nearestCursorTime = cursors[k - 1].time;
+                                break;
+                            case exports.MovementType.move:
+                                nearestCursorGroupIndex = k;
+                                nearestCursorTime = object.endTime;
+                                break;
+                        }
+                    }
                 }
             }
-            let occurrenceStartIndex = hitTimeAfterIndex;
-            while (c[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.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.getStackedPosition(osuBase.Modes.droid)) <= object.object.getRadius(osuBase.Modes.droid) &&
-                    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,
-            });
         }
-        // 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);
+        if (nearestPosition.getDistance(objectEndPosition) ===
+            Number.POSITIVE_INFINITY) {
+            return {
+                position: nearestPosition,
+                cursorIndex: Number.POSITIVE_INFINITY,
+                groupIndex: Number.POSITIVE_INFINITY,
+                cursorGroupIndex: Number.POSITIVE_INFINITY,
+                cursorTime: object.endTime,
+            };
+        }
+        return {
+            position: nearestPosition,
+            cursorIndex: nearestCursorIndex,
+            groupIndex: nearestGroupIndex,
+            cursorGroupIndex: nearestCursorGroupIndex,
+            cursorTime: nearestCursorTime,
+        };
     }
     /**
      * Checks whether a slider was cheesed.
@@ -1561,57 +1759,38 @@ class TwoHandChecker {
      *
      * @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) {
+    checkSliderCheesing(indexedHitObject, hitData) {
         if (!(indexedHitObject.object.object instanceof osuBase.Slider) ||
-            hitData.result === exports.HitResult.miss) {
+            hitData.result === exports.HitResult.miss ||
+            indexedHitObject.cursorIndex === -1) {
             return false;
         }
-        let cursorLoopIndex = Math.max(0, indexedHitObject.occurrenceIndex);
-        const c = this.allCursorOccurrences[indexedHitObject.actualCursorIndex];
-        const acceptableRadius = indexedHitObject.object.object.getRadius(osuBase.Modes.droid) * 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.length; ++j) {
-                if (c[j].time < object.startTime - hitWindowOffset) {
-                    continue;
-                }
-                if (c[j].time > object.startTime + hitWindowOffset) {
-                    break;
-                }
-                if (c[j].position.getDistance(object.getStackedPosition(osuBase.Modes.droid)) <= 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.data.cursorMovement.length);
+        const beatmaps = [
+            osuBase.Utils.deepCopy(this.calculator.beatmap),
+            osuBase.Utils.deepCopy(this.calculator.beatmap),
+        ];
+        for (const beatmap of beatmaps) {
+            beatmap.hitObjects.clear();
+        }
+        let addToSecondBeatmap = true;
         this.indexedHitObjects.forEach((o) => {
-            if (!beatmaps[o.acceptedCursorIndex]) {
-                const map = osuBase.Utils.deepCopy(this.calculator.beatmap);
-                map.hitObjects.clear();
-                beatmaps[o.acceptedCursorIndex] = map;
+            if (!o.is2Handed) {
+                beatmaps[0].hitObjects.add(o.object.object);
+                return;
             }
-            beatmaps[o.acceptedCursorIndex].hitObjects.add(o.object.object);
+            const beatmap = addToSecondBeatmap
+                ? beatmaps[1]
+                : beatmaps[0];
+            beatmap.hitObjects.add(o.object.object);
+            addToSecondBeatmap = !addToSecondBeatmap;
         });
         // Preserve some values that aren't reasonable for them to be changed.
         const preservedValues = this.calculator.objects.map((v) => {
@@ -1624,7 +1803,7 @@ class TwoHandChecker {
         });
         this.calculator.objects.length = 0;
         beatmaps.forEach((beatmap) => {
-            if (!beatmap) {
+            if (beatmap.hitObjects.objects.length === 0) {
                 return;
             }
             const difficultyCalculator = Object.assign(osuBase.Utils.deepCopy(this.calculator), { beatmap: beatmap });
@@ -1641,6 +1820,9 @@ class TwoHandChecker {
             const diffObject = this.calculator.objects[i];
             const indexedHitObject = this.indexedHitObjects[i];
             const preservedValue = preservedValues[i];
+            diffObject.index = i - 1;
+            diffObject.hitObjects.length = 0;
+            diffObject.hitObjects.push(...this.calculator.objects);
             diffObject.noteDensity = preservedValue.noteDensity;
             diffObject.overlappingFactor = preservedValue.overlappingFactor;
             diffObject.rhythmStrain = preservedValue.rhythmStrain;
@@ -2207,7 +2389,7 @@ class ReplayObjectData {
      * For circles, this is the offset at which the circle was hit. If the hit accuracy is 10000, it means the circle was tapped too late ([game source code](https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/HitCircle.java#L298-L306)).
      *
      * For sliders, this is the offset at which the slider head was hit. For
-     * sliderbreaks, the accuracy would be `(hit window 50)ms + 13ms` ([game source code](https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/Slider.java#L821)).
+     * sliderbreaks, the accuracy would be `Math.floor(<hit window 50>ms) + 13ms` ([game source code](https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/Slider.java#L821)).
      *
      * For spinners, this is the total amount at which the spinner was spinned:
      * ```js