@rian8337/osu-droid-replay-analyzer 3.0.0-beta.31 → 3.0.0-beta.33

package/dist/index.js

@@ -130,6 +130,12 @@ class CursorOccurrenceGroup {
     get endTime() {
         return this._up?.time ?? this._moves.at(-1)?.time ?? this._down.time;
     }
+    /**
+     * The duration this cursor occurrence group is active for.
+     */
+    get duration() {
+        return this.endTime - this.startTime;
+    }
     /**
      * All cursor occurrences in this group.
      *
@@ -828,73 +834,69 @@ class ThreeFingerChecker {
      * @param cursorIndexes The indexes of the cursor instance that has at least an occurrence in the section.
      */
     findDragIndex(sectionObjects, sectionReplayObjectData, cursorIndexes) {
-        let objectIndex = sectionObjects.findIndex((v, i) => !(v.object instanceof osuBase.Spinner) &&
-            sectionReplayObjectData[i].result !== exports.HitResult.miss);
-        if (objectIndex === -1) {
-            return -1;
-        }
-        while (cursorIndexes.length > 0) {
-            if (objectIndex === sectionObjects.length) {
-                break;
+        const isPrecise = this.calculator.mods.some((m) => m instanceof osuBase.ModPrecise);
+        const hitWindow50 = this.hitWindow.hitWindowFor50(isPrecise);
+        for (let i = 0; i < sectionObjects.length && cursorIndexes.every((v) => v !== -1); ++i) {
+            const object = sectionObjects[i];
+            const objectData = sectionReplayObjectData[i];
+            if (object.object instanceof osuBase.Spinner ||
+                objectData.result === exports.HitResult.miss) {
+                continue;
             }
-            const o = sectionObjects[objectIndex];
-            const s = sectionReplayObjectData[objectIndex];
-            ++objectIndex;
-            if (s.result === exports.HitResult.miss) {
+            // Exclude sliderbreaks.
+            if (object.object instanceof osuBase.Slider &&
+                objectData.accuracy === Math.floor(hitWindow50) + 13) {
                 continue;
             }
-            // Get the cursor instance that is closest to the object's hit time.
+            const objectPosition = object.object.getStackedPosition(osuBase.Modes.droid);
+            const hitTime = object.object.startTime + objectData.accuracy;
+            // Observe the cursor position at the object's hit time.
             for (let j = 0; j < cursorIndexes.length; ++j) {
-                const c = this.data.cursorMovement[cursorIndexes[j]];
-                // Cursor instances aren't always recorded at all times,
-                // therefore the game emulates the movement between
-                // movementType.MOVE cursors.
-                const hitTime = o.object.startTime + s.accuracy;
-                const cursorGroup = c.occurrenceGroups.find((v) => v.isActiveAt(hitTime));
-                if (!cursorGroup) {
+                if (cursorIndexes[j] === -1) {
                     continue;
                 }
-                const cursors = cursorGroup.allOccurrences;
-                const nextHitIndex = cursors.findIndex((v) => v.time >= hitTime);
-                const hitIndex = nextHitIndex - 1;
-                if (hitIndex <= -1) {
-                    cursorIndexes[j] = -1;
+                const cursorData = this.data.cursorMovement[cursorIndexes[j]];
+                const cursorGroup = cursorData.occurrenceGroups.find((v) => v.isActiveAt(hitTime));
+                if (!cursorGroup) {
                     continue;
                 }
-                const cursorPosition = new osuBase.Vector2(cursors[hitIndex].position.x, cursors[hitIndex].position.y);
-                let isInObject = false;
-                if (cursors[nextHitIndex].id === exports.MovementType.move) {
-                    // Try to interpolate movement between two movementType.MOVE cursor every 1ms.
-                    // This minimizes rounding error.
-                    for (let mSecPassed = cursors[hitIndex].time; mSecPassed <= cursors[nextHitIndex].time; ++mSecPassed) {
-                        const t = (mSecPassed - cursors[nextHitIndex].time) /
-                            (cursors[hitIndex].time -
-                                cursors[nextHitIndex].time);
-                        cursorPosition.x = osuBase.Interpolation.lerp(cursors[hitIndex].position.x, cursors[nextHitIndex].position.x, t);
-                        cursorPosition.y = osuBase.Interpolation.lerp(cursors[hitIndex].position.y, cursors[nextHitIndex].position.y, t);
-                        if (o.object
-                            .getStackedPosition(osuBase.Modes.droid)
-                            .getDistance(cursorPosition) <=
-                            o.object.getRadius(osuBase.Modes.droid)) {
-                            isInObject = true;
+                const cursors = cursorGroup.allOccurrences;
+                for (let k = 1; k < cursors.length; ++k) {
+                    const cursor = cursors[k];
+                    const prevCursor = cursors[k - 1];
+                    if (prevCursor.time <
+                        object.object.startTime - hitWindow50) {
+                        continue;
+                    }
+                    if (prevCursor.time >
+                        object.object.startTime + hitWindow50) {
+                        break;
+                    }
+                    let isInObject = false;
+                    switch (cursor.id) {
+                        case exports.MovementType.up:
+                            isInObject =
+                                prevCursor.position.getDistance(objectPosition) <= object.object.getRadius(osuBase.Modes.droid);
                             break;
-                        }
+                        case exports.MovementType.move:
+                            // Interpolate movement.
+                            for (let mSecPassed = prevCursor.time; !isInObject &&
+                                mSecPassed <=
+                                    Math.min(cursor.time, object.object.startTime + hitWindow50); ++mSecPassed) {
+                                const t = (mSecPassed - prevCursor.time) /
+                                    (cursor.time - prevCursor.time);
+                                const cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
+                                isInObject =
+                                    objectPosition.getDistance(cursorPosition) <= object.object.getRadius(osuBase.Modes.droid);
+                            }
+                    }
+                    if (!isInObject) {
+                        cursorIndexes[j] = -1;
                     }
-                }
-                else {
-                    isInObject =
-                        o.object
-                            .getStackedPosition(osuBase.Modes.droid)
-                            .getDistance(cursorPosition) <=
-                            o.object.getRadius(osuBase.Modes.droid);
-                }
-                if (!isInObject) {
-                    cursorIndexes[j] = -1;
                 }
             }
-            cursorIndexes = cursorIndexes.filter((v) => v !== -1);
         }
-        return cursorIndexes.shift() ?? -1;
+        return cursorIndexes.find((v) => v !== -1) ?? -1;
     }
     /**
      * Redivides the beatmap into sections.
@@ -994,13 +996,6 @@ class ThreeFingerChecker {
                     exports.HitResult.miss
                     ? objectData[beatmapSection.lastObjectIndex].accuracy
                     : this.hitWindow.hitWindowFor50(isPrecise));
-            // Filter cursor instances during section.
-            this.downCursorInstances.forEach((c) => {
-                const i = c.findIndex((t) => t.time >= startTime);
-                if (i !== -1) {
-                    c = c.slice(i);
-                }
-            });
             const cursorAmounts = [];
             const cursorVectorTimes = [];
             for (let i = 0; i < this.downCursorInstances.length; ++i) {
@@ -1069,7 +1064,8 @@ class ThreeFingerChecker {
                 .slice(2);
             // Ignore cursor presses that are only 1 for now since they are very likely to be accidental
             if ((threeFingerRatio > this.threeFingerRatioThreshold &&
-                cursorAmounts.filter((v) => v > 1).length > 3) ||
+                cursorAmounts.filter((v) => v > 1).length >
+                    fingerSplitIndex) ||
                 validPresses.length > 0) {
                 // Strain factor
                 const objectCount = beatmapSection.lastObjectIndex -
@@ -1130,6 +1126,20 @@ class IndexedHitObject {
      * the hitobject or it did not meet the criteria for detection.
      */
     cursorIndex;
+    /**
+     * The group index of the cursor within 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.
+     */
+    groupIndex;
+    /**
+     * The occurrence index within the group of the cursor within 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.
+     */
+    occurrenceIndex;
     /**
      * The angle of the movement of the cursor towards the next hitobject.
      */
@@ -1143,23 +1153,34 @@ class IndexedHitObject {
      */
     object;
     /**
-     * Whether the hitobject was most likely two-handed.
+     * The position of the cursor at the end of this hitobject.
+     *
+     * Will be altered during detection.
      */
-    get is2Handed() {
-        return this.angle !== null && this.angle >= Math.PI / 6;
-    }
+    endCursorPosition;
+    /**
+     * Whether the hitobject is likely two-handed.
+     */
+    is2Handed;
     /**
      * @param object The underlying difficulty hitobject.
      * @param cursorIndex The cursor index that moves towards the hitobject.
+     * @param groupIndex The group index of the cursor within the cursor index that hits the hitobject.
+     * @param occurrenceIndex The occurrence index within the group of the cursor within the cursor index that hits the hitobject.
      * @param angle The angle of the movement of the cursor that moves towards the hitobject.
      */
-    constructor(object, cursorIndex, angle) {
+    constructor(object, cursorIndex, groupIndex, occurrenceIndex, angle, is2Handed) {
         this.object = object;
         this.cursorIndex = cursorIndex;
+        this.groupIndex = groupIndex;
+        this.occurrenceIndex = occurrenceIndex;
         this.angle = angle;
+        this.is2Handed = is2Handed;
+        this.endCursorPosition = this.object.object.getStackedEndPosition(osuBase.Modes.droid);
     }
 }
 
+// import { writeFileSync } from "fs";
 /**
  * Utility to check whether or not a beatmap is two-handed.
  */
@@ -1184,6 +1205,7 @@ class TwoHandChecker {
      * The 50 osu!droid hit window of the analyzed beatmap.
      */
     hitWindow50;
+    // private csvString: string;
     /**
      * @param calculator The difficulty calculator to analyze.
      * @param data The data of the replay.
@@ -1198,17 +1220,86 @@ class TwoHandChecker {
         }).calculate();
         this.hitWindow = new osuBase.DroidHitWindow(stats.od);
         this.hitWindow50 = this.hitWindow.hitWindowFor50(calculator.mods.some((m) => m instanceof osuBase.ModPrecise));
+        // this.csvString = `Mods,${
+        //     data.convertedMods.reduce((a, m) => a + m.acronym, "") || "NM"
+        // }\nCombo,${data.maxCombo}\nAccuracy,"${(
+        //     data.accuracy.value() * 100
+        // ).toFixed(2)}% [${data.accuracy.n300}/${data.accuracy.n100}/${
+        //     data.accuracy.n50
+        // }/${
+        //     data.accuracy.nmiss
+        // }]"\n\nIndex,Type,StartTime,EndTime,DeltaTime,CursorIndex,GroupIndex,CursorDuration\n`;
     }
     /**
      * Checks if a beatmap is two-handed.
      */
     check() {
         if (this.data.cursorMovement.filter((v) => v.occurrenceGroups.length > 0).length <= 1) {
-            return { is2Hand: false, cursorIndexes: [] };
+            return { is2Hand: false, twoHandedNoteCount: 0 };
         }
         this.indexHitObjects();
-        this.applyPenalty();
-        return { is2Hand: false, cursorIndexes: [] };
+        // this.applyPenalty();
+        // for (let i = 0; i < this.calculator.objects.length; ++i) {
+        //     const object: PlaceableHitObject =
+        //         this.calculator.objects[i].object;
+        //     if (object instanceof Spinner) {
+        //         continue;
+        //     }
+        //     let deltaTime: number = 0;
+        //     if (i > 0) {
+        //         const prevObject: PlaceableHitObject =
+        //             this.calculator.objects[i - 1].object;
+        //         deltaTime = Math.max(
+        //             object.startTime - prevObject.startTime,
+        //             25
+        //         );
+        //         if (prevObject instanceof Slider) {
+        //             deltaTime = Math.max(
+        //                 deltaTime - prevObject.lazyTravelTime,
+        //                 25
+        //             );
+        //         }
+        //     }
+        //     const objectInfo = this.getCursorPositionForObjectStart(i);
+        //     this.csvString += `${i},${object.typeStr()},${object.startTime},${
+        //         object instanceof Slider
+        //             ? object.startTime + object.lazyTravelTime
+        //             : object.endTime
+        //     },${deltaTime},${objectInfo.cursorIndex},${objectInfo.groupIndex},${
+        //         this.data.cursorMovement[objectInfo.cursorIndex]
+        //             ?.occurrenceGroups[objectInfo.groupIndex]?.duration ??
+        //         Number.POSITIVE_INFINITY
+        //     }\n`;
+        // }
+        // writeFileSync(
+        //     join(
+        //         process.cwd(),
+        //         "files",
+        //         `${this.data.playerName} - ${this.calculator.beatmap.metadata.fullTitle}.csv`
+        //     ),
+        //     this.csvString
+        // );
+        let twoHandedNoteCount = 0;
+        const maxStrain = Math.max(...this.calculator.objects.map((v) => v.aimStrainWithSliders));
+        if (maxStrain) {
+            twoHandedNoteCount = this.indexedHitObjects.reduce((total, object) => {
+                if (!object.is2Handed) {
+                    return total;
+                }
+                return (total +
+                    1 /
+                        (1 +
+                            Math.exp(-((object.object.aimStrainWithSliders /
+                                maxStrain) *
+                                12 -
+                                6))));
+            }, 0);
+        }
+        return {
+            is2Hand: twoHandedNoteCount >
+                this.calculator.attributes.aimNoteCount * 0.15,
+            twoHandedNoteCount: twoHandedNoteCount,
+        };
     }
     /**
      * Converts hitobjects into indexed hit objects.
@@ -1221,6 +1312,7 @@ class TwoHandChecker {
             indexes.push(indexedHitObject.cursorIndex);
             this.indexedHitObjects.push(indexedHitObject);
         }
+        // console.log("Aim note count:", this.calculator.attributes.aimNoteCount);
         // console.log(
         //     this.indexedHitObjects.filter((v) => v.cursorIndex !== -1).length +
         //         1,
@@ -1248,8 +1340,7 @@ class TwoHandChecker {
         //             (v) =>
         //                 // v.cursorIndex === -1 &&
         //                 // v.object.aimStrainWithSliders > 200 &&
-        //                 v.object.deltaTime > 75 &&
-        //                 v.is2Handed
+        //                 v.object.deltaTime > 75 && v.is2Handed
         //         )
         //         .map((v) => {
         //             return {
@@ -1280,17 +1371,17 @@ class TwoHandChecker {
         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);
+            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
         }
         // We don't care if the aim strain is too low.
-        if (diffObject.aimStrainWithSliders < 200) {
-            return new IndexedHitObject(diffObject, -1, null);
-        }
+        // if (diffObject.aimStrainWithSliders < 200) {
+        //     return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+        // }
         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);
+            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
         }
         const objectStartPosition = object.getStackedPosition(osuBase.Modes.droid);
         let prevObjectEndPosition = prevObject.getStackedEndPosition(osuBase.Modes.droid);
@@ -1309,9 +1400,10 @@ class TwoHandChecker {
         const prevToCurrentMovement = object
             .getStackedPosition(osuBase.Modes.droid)
             .subtract(prevObjectEndPosition);
+        const radius = object.getRadius(osuBase.Modes.droid);
         // 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);
+        if (prevToCurrentMovement.length <= radius) {
+            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
         }
         // 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
@@ -1322,10 +1414,21 @@ class TwoHandChecker {
         // 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.
+        // If the angle isn't fulfilled, check for the "initial velocity", which is the movement velocity from the
+        // previous object's end time to the current object's start time and the "air velocity", which is the
+        // velocity from the previous object's cursor release time to the next object's cursor press time. If the velocity
+        // during the held tap is significantly less than the estimated velocity, it's considered two hand.
         const objectInformation = this.getCursorPositionForObjectStart(objectIndex);
         const prevObjectInformation = this.getCursorPositionForObjectEnd(objectIndex - 1);
+        this.indexedHitObjects[objectIndex - 1].endCursorPosition =
+            prevObjectInformation.position;
         if (prevObjectInformation.position.x === Number.POSITIVE_INFINITY) {
-            return new IndexedHitObject(diffObject, -1, null);
+            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+        }
+        if (prevObjectInformation.cursorIndex ===
+            objectInformation.cursorIndex &&
+            prevObjectInformation.groupIndex === objectInformation.groupIndex) {
+            return new IndexedHitObject(diffObject, objectInformation.cursorIndex, objectInformation.groupIndex, prevObjectInformation.occurrenceIndex, 0, false);
         }
         const cursorData = this.data.cursorMovement[prevObjectInformation.cursorIndex];
         // There can be multiple angles to which the cursor moves towards the next object.
@@ -1334,7 +1437,7 @@ class TwoHandChecker {
         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) {
+        for (let i = prevObjectInformation.occurrenceIndex + 1; i < cursors.length; ++i) {
             const cursor = cursors[i];
             const prevCursor = cursors[i - 1];
             if (cursor.position.equals(prevCursor.position)) {
@@ -1350,167 +1453,64 @@ class TwoHandChecker {
             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 is2Handed = finalAngle >= Math.PI / 6;
+        // if (is2Handed) {
+        //     // If angle isn't fulfilled, check for cursor velocity.
+        //     let deltaTime: number = Math.max(
+        //         object.startTime - prevObject.startTime,
+        //         25
         //     );
-        //     const endTimeCursor: CursorOccurrence = cursors[cursorIndex];
-        //     if (endTimeCursor.id === MovementType.up) {
-        //         continue;
+        //     if (prevObject instanceof Slider) {
+        //         deltaTime = Math.max(deltaTime - prevObject.lazyTravelTime, 25);
         //     }
-        //     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
-        //             ))
+        //     // "Initial velocity" is the movement velocity from the previous object's end time to the current object's start time.
+        //     const initialVelocity: number =
+        //         objectStartPosition.getDistance(prevObjectEndPosition) /
+        //         deltaTime;
+        //     // const finalCursor: CursorOccurrence =
+        //     //     cursorGroup.moves.at(-1) ?? cursorGroup.down;
+        //     const currentCursorGroup: CursorOccurrenceGroup =
+        //         this.data.cursorMovement[objectInformation.cursorIndex]
+        //             .occurrenceGroups[objectInformation.groupIndex];
+        //     // const cursorDistance: number = currentCursorGroup.down.position.getDistance(
+        //     //     finalCursor.position
+        //     // );
+        //     const cursorDuration: number = Math.max(
+        //         0,
+        //         currentCursorGroup.startTime - cursorGroup.endTime
+        //     );
+        //     // "Air velocity" is the cursor velocity from the moment the previous cursor release action to the next cursor press action.
+        //     // const airVelocity: number = cursorDistance / cursorDuration;
+        //     is2Handed =
+        //         // airVelocity / initialVelocity < 0.8 &&
+        //         cursorDuration / deltaTime > 0.2;
+        //     for (
+        //         let i = prevObjectInformation.occurrenceIndex + 1;
+        //         i < cursors.length && is2Handed;
+        //         ++i
         //     ) {
-        //         ++cursorIndex;
-        //     }
-        //     const endCursorToCurrentMovement: Vector2 =
-        //         objectStartPosition.subtract(actualEndCursorPosition);
-        //     for (; cursorIndex < cursors.length; ++cursorIndex) {
-        //         const cursor: CursorOccurrence = cursors[cursorIndex];
-        //         const prevCursor: CursorOccurrence = cursors[cursorIndex - 1];
+        //         const cursor: CursorOccurrence = cursors[i];
+        //         const prevCursor: CursorOccurrence = cursors[i - 1];
         //         if (
-        //             cursor.id === MovementType.up ||
-        //             prevCursor.time >= cursorTimeLimit
+        //             cursor.position.equals(prevCursor.position) ||
+        //             cursor.time === prevCursor.time
         //         ) {
-        //             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;
+        //         if (cursor.id === MovementType.up) {
+        //             break;
         //         }
+        //         // "Cursor velocity" is the velocity from the previous object's cursor release time to the current object's press time.
+        //         const cursorVelocity: number =
+        //             cursor.position.getDistance(prevCursor.position) /
+        //             (cursor.time - prevCursor.time);
+        //         is2Handed = cursorVelocity / initialVelocity < 0.8;
         //     }
-        //     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
-        // );
+        if (!Number.isFinite(finalAngle)) {
+            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+        }
+        return new IndexedHitObject(diffObject, prevObjectInformation.cursorIndex, prevObjectInformation.groupIndex, prevObjectInformation.occurrenceIndex, finalAngle, is2Handed);
     }
     /**
      * Gets the position of the cursor that presses an object.
@@ -1527,7 +1527,7 @@ class TwoHandChecker {
                 position: objectPosition,
                 cursorIndex: 0,
                 groupIndex: Number.POSITIVE_INFINITY,
-                cursorGroupIndex: Number.POSITIVE_INFINITY,
+                occurrenceIndex: Number.POSITIVE_INFINITY,
                 cursorTime: object.startTime,
             };
         }
@@ -1580,7 +1580,7 @@ class TwoHandChecker {
                                 position: down.position,
                                 cursorIndex: i,
                                 groupIndex: j,
-                                cursorGroupIndex: 0,
+                                occurrenceIndex: 0,
                                 cursorTime: down.time,
                             };
                         }
@@ -1590,7 +1590,7 @@ class TwoHandChecker {
                             position: down.position,
                             cursorIndex: i,
                             groupIndex: j,
-                            cursorGroupIndex: 0,
+                            occurrenceIndex: 0,
                             cursorTime: down.time,
                         };
                     }
@@ -1659,7 +1659,7 @@ class TwoHandChecker {
                 position: nearestPosition,
                 cursorIndex: Number.POSITIVE_INFINITY,
                 groupIndex: Number.POSITIVE_INFINITY,
-                cursorGroupIndex: Number.POSITIVE_INFINITY,
+                occurrenceIndex: Number.POSITIVE_INFINITY,
                 cursorTime: object.startTime,
             };
         }
@@ -1667,7 +1667,7 @@ class TwoHandChecker {
             position: nearestPosition,
             cursorIndex: nearestCursorIndex,
             groupIndex: nearestGroupIndex,
-            cursorGroupIndex: nearestCursorGroupIndex,
+            occurrenceIndex: nearestCursorGroupIndex,
             cursorTime: nearestCursorTime,
         };
     }
@@ -1760,7 +1760,7 @@ class TwoHandChecker {
                 position: nearestPosition,
                 cursorIndex: Number.POSITIVE_INFINITY,
                 groupIndex: Number.POSITIVE_INFINITY,
-                cursorGroupIndex: Number.POSITIVE_INFINITY,
+                occurrenceIndex: Number.POSITIVE_INFINITY,
                 cursorTime: object.endTime,
             };
         }
@@ -1768,7 +1768,7 @@ class TwoHandChecker {
             position: nearestPosition,
             cursorIndex: nearestCursorIndex,
             groupIndex: nearestGroupIndex,
-            cursorGroupIndex: nearestCursorGroupIndex,
+            occurrenceIndex: nearestCursorGroupIndex,
             cursorTime: nearestCursorTime,
         };
     }
@@ -1804,6 +1804,7 @@ class TwoHandChecker {
         this.indexedHitObjects.forEach((o) => {
             if (!o.is2Handed) {
                 beatmaps[0].hitObjects.add(o.object.object);
+                addToSecondBeatmap = true;
                 return;
             }
             const beatmap = addToSecondBeatmap
@@ -1861,6 +1862,173 @@ class TwoHandChecker {
     }
 }
 
+/**
+ * Utility to check whether relevant sliders in a beatmap are cheesed.
+ */
+class SliderCheeseChecker {
+    /**
+     * The difficulty calculator that is being analyzed.
+     */
+    calculator;
+    /**
+     * The data of the replay.
+     */
+    data;
+    /**
+     * The osu!droid hitwindow of the analyzed beatmap.
+     */
+    hitWindow;
+    /**
+     * The 50 osu!droid hit window of the analyzed beatmap.
+     */
+    hitWindow50;
+    /**
+     * The indexes of objects that were cheesed.
+     */
+    cheesedObjectIndexes = [];
+    /**
+     * @param calculator The difficulty calculator to analyze.
+     * @param data The data of the replay.
+     */
+    constructor(calculator, data) {
+        this.calculator = calculator;
+        this.data = data;
+        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)),
+        }).calculate();
+        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
+        this.hitWindow50 = this.hitWindow.hitWindowFor50(calculator.mods.some((m) => m instanceof osuBase.ModPrecise));
+    }
+    /**
+     * Checks if relevant sliders in the given beatmap was cheesed.
+     *
+     * Returns a number that can be passed to a `DroidPerformanceCalculator`
+     * to alter the aim performance value.
+     */
+    check() {
+        if (this.calculator.attributes.sliderCount === 0) {
+            return 1;
+        }
+        this.checkSliderCheesing();
+        return this.calculateSliderCheesePenalty();
+    }
+    /**
+     * Checks for sliders that were cheesed.
+     */
+    checkSliderCheesing() {
+        // Current loop indexes are stored for efficiency.
+        const cursorLoopIndexes = osuBase.Utils.initializeArray(10, 0);
+        const acceptableRadius = this.calculator.objects[0].object.getRadius(osuBase.Modes.droid) * 2;
+        for (let i = 0; i < this.calculator.objects.length; ++i) {
+            const diffObject = this.calculator.objects[i];
+            const { object } = diffObject;
+            if (diffObject.travelDistance === 0 ||
+                !(object instanceof osuBase.Slider)) {
+                continue;
+            }
+            const objectStartPosition = object.getStackedPosition(osuBase.Modes.droid);
+            const objectData = this.data.hitObjectData[i];
+            // If a slider break occurs, we disregard the check for that slider.
+            if (objectData.accuracy === Math.floor(this.hitWindow50) + 13) {
+                continue;
+            }
+            let isCheesed = false;
+            for (let j = 0; j < this.data.cursorMovement.length; ++j) {
+                if (isCheesed) {
+                    break;
+                }
+                const cursorGroups = this.data.cursorMovement[j].occurrenceGroups;
+                for (let k = cursorLoopIndexes[j]; k < cursorGroups.length; k = ++cursorLoopIndexes[j]) {
+                    const group = cursorGroups[k];
+                    if (group.startTime < object.startTime - this.hitWindow50) {
+                        continue;
+                    }
+                    if (group.startTime > object.startTime + this.hitWindow50) {
+                        break;
+                    }
+                    if (group.down.position.getDistance(objectStartPosition) >
+                        acceptableRadius) {
+                        continue;
+                    }
+                    // Track cursor movement to see if it lands on every tick.
+                    let occurrenceLoopIndex = 1;
+                    let isSliderFulfilled = true;
+                    const { allOccurrences } = group;
+                    for (let l = 1; l < object.nestedHitObjects.length; ++l) {
+                        if (!isSliderFulfilled) {
+                            break;
+                        }
+                        const tickWasHit = objectData.tickset[l - 1];
+                        if (!tickWasHit) {
+                            continue;
+                        }
+                        const nestedObject = object.nestedHitObjects[l];
+                        const nestedPosition = nestedObject.getStackedPosition(osuBase.Modes.droid);
+                        while (occurrenceLoopIndex < allOccurrences.length &&
+                            allOccurrences[occurrenceLoopIndex].time <
+                                nestedObject.startTime) {
+                            ++occurrenceLoopIndex;
+                        }
+                        if (occurrenceLoopIndex === allOccurrences.length) {
+                            continue;
+                        }
+                        const occurrence = allOccurrences[occurrenceLoopIndex];
+                        const prevOccurrence = allOccurrences[occurrenceLoopIndex - 1];
+                        switch (occurrence.id) {
+                            case exports.MovementType.move: {
+                                // Interpolate cursor position during nested object time.
+                                const t = (nestedObject.startTime -
+                                    prevOccurrence.time) /
+                                    (occurrence.time - prevOccurrence.time);
+                                const cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevOccurrence.position.x, occurrence.position.x, t), osuBase.Interpolation.lerp(prevOccurrence.position.y, occurrence.position.y, t));
+                                const distance = cursorPosition.getDistance(nestedPosition);
+                                if (distance > acceptableRadius) {
+                                    isSliderFulfilled = false;
+                                }
+                                break;
+                            }
+                            case exports.MovementType.up:
+                                if (prevOccurrence.position.getDistance(nestedPosition) > acceptableRadius) {
+                                    isSliderFulfilled = false;
+                                    break;
+                                }
+                        }
+                    }
+                    if (!isSliderFulfilled) {
+                        isCheesed = true;
+                        break;
+                    }
+                }
+            }
+            if (isCheesed) {
+                this.cheesedObjectIndexes.push(i);
+            }
+        }
+    }
+    /**
+     * Calculates the slider cheese penalty.
+     */
+    calculateSliderCheesePenalty() {
+        let calculator;
+        if (this.calculator instanceof osuDifficultyCalculator.DroidDifficultyCalculator) {
+            calculator = new osuDifficultyCalculator.DroidDifficultyCalculator(this.calculator.beatmap);
+        }
+        else {
+            calculator = new osuRebalanceDifficultyCalculator.DroidDifficultyCalculator(this.calculator.beatmap);
+        }
+        Object.assign(calculator.attributes, this.calculator.attributes);
+        calculator.stats = this.calculator.stats;
+        calculator.generateDifficultyHitObjects();
+        for (const index of this.cheesedObjectIndexes) {
+            calculator.objects[index].travelDistance = 0;
+        }
+        calculator.calculateAim();
+        return this.calculator.aim / calculator.aim;
+    }
+}
+
 /**
  * A replay analyzer that analyzes a replay from osu!droid.
  *
@@ -1890,7 +2058,7 @@ class ReplayAnalyzer {
      */
     is2Hand;
     /**
-     * The beatmap that is being analyzed. `DroidStarRating` or `RebalanceDroidStarRating` is required for three finger or two hand analyzing.
+     * The beatmap that is being analyzed. `DroidDifficultyCalculator` or `RebalanceDroidDifficultyCalculator` is required for three finger or two hand analyzing.
      */
     beatmap;
     /**
@@ -1905,6 +2073,10 @@ class ReplayAnalyzer {
      * Penalty value used to penalize dpp for 3 finger abuse.
      */
     tapPenalty = 1;
+    /**
+     * Penalty value used to penalize dpp for slider cheesing.
+     */
+    sliderCheesePenalty = 1;
     /**
      * Whether this replay has been checked against 3 finger usage.
      */
@@ -1914,11 +2086,13 @@ class ReplayAnalyzer {
      */
     hasBeenCheckedFor2Hand = false;
     /**
-     * The cursor indexes at which each object was hit.
-     *
-     * This is filled after 2 hand usage has been checked.
+     * Whether this repla has been checked against slider cheesing.
      */
-    twoHandCursorIndexes = [];
+    hasBeenCheckedForSliderCheesing = false;
+    /**
+     * The amount of two-handed objects.
+     */
+    twoHandedNoteCount = 0;
     // Sizes of primitive data types in Java (in bytes)
     BYTE_LENGTH = 1;
     SHORT_LENGTH = 2;
@@ -2364,7 +2538,7 @@ class ReplayAnalyzer {
     /**
      * Checks if a play is using 3 fingers.
      *
-     * Requires `analyze()` to be called first and `map` to be defined as `DroidStarRating` or `RebalanceDroidStarRating`.
+     * Requires `analyze()` to be called first and `map` to be defined as `DroidDifficultyCalculator`.
      */
     checkFor3Finger() {
         if (!(this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
@@ -2381,7 +2555,7 @@ class ReplayAnalyzer {
     /**
      * Checks if a play is using 2 hands.
      *
-     * Requires `analyze()` to be called first and `map` to be defined as `DroidStarRating` or `RebalanceDroidStarRating`.
+     * Requires `analyze()` to be called first and `map` to be defined as `DroidDifficultyCalculator`.
      */
     checkFor2Hand() {
         if (!(this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
@@ -2392,9 +2566,24 @@ class ReplayAnalyzer {
         const twoHandChecker = new TwoHandChecker(this.beatmap, this.data);
         const result = twoHandChecker.check();
         this.is2Hand = result.is2Hand;
-        this.twoHandCursorIndexes = result.cursorIndexes;
+        this.twoHandedNoteCount = result.twoHandedNoteCount;
         this.hasBeenCheckedFor2Hand = true;
     }
+    /**
+     * Checks if a play has cheesed sliders.
+     *
+     * Requires `analyze()` to be called first and `map` to be defined as `DroidDifficultyCalculator`.
+     */
+    checkForSliderCheesing() {
+        if (!(this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
+            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator) ||
+            !this.data) {
+            return;
+        }
+        const sliderCheeseChecker = new SliderCheeseChecker(this.beatmap, this.data);
+        this.sliderCheesePenalty = sliderCheeseChecker.check();
+        this.hasBeenCheckedForSliderCheesing = true;
+    }
 }
 
 /**