@rian8337/osu-droid-replay-analyzer 4.0.0-beta.76 → 4.0.0-beta.78

package/dist/index.js

@@ -709,6 +709,222 @@ class RebalanceThreeFingerChecker {
     }
 }
 
+/**
+ * Utility to check whether relevant sliders in a beatmap are cheesed for rebalance scores..
+ */
+class RebalanceSliderCheeseChecker {
+    /**
+     * @param beatmap The beatmap to analyze.
+     * @param data The data of the replay.
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
+     */
+    constructor(beatmap, data, difficultyAttributes) {
+        this.beatmap = beatmap;
+        this.data = data;
+        this.difficultyAttributes = difficultyAttributes;
+        this.hitWindow50 = difficultyAttributes.mods.has(osuBase.ModPrecise)
+            ? new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od).mehWindow
+            : new osuBase.DroidHitWindow(beatmap.difficulty.od).mehWindow;
+        this.isHardRock = difficultyAttributes.mods.has(osuBase.ModHardRock);
+    }
+    /**
+     * Checks if relevant sliders in the given beatmap was cheesed.
+     */
+    check() {
+        if (this.difficultyAttributes.difficultSliders.length === 0 ||
+            (this.difficultyAttributes.sliderFactor === 1 &&
+                this.difficultyAttributes.flashlightSliderFactor === 1)) {
+            return {
+                aimPenalty: 1,
+                flashlightPenalty: 1,
+            };
+        }
+        const cheesedDifficultyRatings = this.checkSliderCheesing();
+        return this.calculateSliderCheesePenalty(cheesedDifficultyRatings);
+    }
+    /**
+     * Checks for sliders that were cheesed.
+     */
+    checkSliderCheesing() {
+        const { objects } = this.beatmap.hitObjects;
+        const cheesedDifficultyRatings = [];
+        // Current loop indices are stored for efficiency.
+        const cursorLoopIndices = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
+        const acceptableRadius = objects[0].radius * 2;
+        // Sort difficult sliders by index so that cursor loop indices work properly.
+        for (const difficultSlider of this.difficultyAttributes.difficultSliders
+            .slice()
+            .sort((a, b) => a.index - b.index)) {
+            if (difficultSlider.index >= this.data.hitObjectData.length) {
+                continue;
+            }
+            const object = objects[difficultSlider.index];
+            const objectData = this.data.hitObjectData[difficultSlider.index];
+            // If a miss or slider break occurs, we disregard the check for that slider.
+            if (objectData.result === exports.HitResult.miss ||
+                -this.hitWindow50 > objectData.accuracy ||
+                objectData.accuracy >
+                    Math.min(this.hitWindow50, object.duration)) {
+                continue;
+            }
+            const objectStartPosition = object.stackedPosition;
+            // These time boundaries should consider the delta time between the previous and next
+            // object as well as their hit accuracy. However, they are somewhat complicated to
+            // compute and the accuracy gain is small. As such, let's settle with 50 hit window.
+            const minTimeLimit = object.startTime - this.hitWindow50;
+            const maxTimeLimit = object.startTime + this.hitWindow50;
+            // Get the closest tap distance across all cursors.
+            const closestDistances = [];
+            const closestGroupIndices = [];
+            for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+                const cursorGroups = this.data.cursorMovement[i].occurrenceGroups;
+                let closestDistance = Number.POSITIVE_INFINITY;
+                let closestIndex = cursorGroups.length;
+                for (let j = cursorLoopIndices[i]; j < cursorGroups.length; j = ++cursorLoopIndices[i]) {
+                    const group = cursorGroups[j];
+                    if (group.endTime < minTimeLimit) {
+                        continue;
+                    }
+                    if (group.startTime > maxTimeLimit) {
+                        break;
+                    }
+                    if (group.startTime >= minTimeLimit) {
+                        const position = this.getCursorPosition(group.down);
+                        const distance = position.getDistance(objectStartPosition);
+                        if (closestDistance > distance) {
+                            closestDistance = distance;
+                            closestIndex = j;
+                        }
+                        if (closestDistance <= acceptableRadius / 2) {
+                            break;
+                        }
+                    }
+                    // Normally, we check if there are cursor presses within the group's active time.
+                    // However, some funky workarounds are used throughout the game for replays, so
+                    // for the time being we only check for cursor distances across the group.
+                    const { allOccurrences } = group;
+                    for (let k = 1; k < allOccurrences.length; ++k) {
+                        const cursor = allOccurrences[k];
+                        const prevCursor = allOccurrences[k - 1];
+                        let distance = Number.POSITIVE_INFINITY;
+                        const currentPosition = this.getCursorPosition(cursor);
+                        const prevPosition = this.getCursorPosition(prevCursor);
+                        switch (cursor.id) {
+                            case exports.MovementType.up:
+                                distance =
+                                    prevPosition.getDistance(objectStartPosition);
+                                break;
+                            case exports.MovementType.move:
+                                for (let mSecPassed = Math.max(prevCursor.time, minTimeLimit); mSecPassed <=
+                                    Math.min(cursor.time, maxTimeLimit); ++mSecPassed) {
+                                    const t = (mSecPassed - prevCursor.time) /
+                                        (cursor.time - prevCursor.time);
+                                    const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                                    distance =
+                                        cursorPosition.getDistance(objectStartPosition);
+                                    if (closestDistance > distance) {
+                                        closestDistance = distance;
+                                        closestIndex = j;
+                                    }
+                                    if (closestDistance <=
+                                        acceptableRadius / 2) {
+                                        break;
+                                    }
+                                }
+                        }
+                        if (closestDistance > distance) {
+                            closestDistance = distance;
+                            closestIndex = j;
+                        }
+                        if (closestDistance <= acceptableRadius / 2) {
+                            break;
+                        }
+                    }
+                }
+                closestDistances.push(closestDistance);
+                closestGroupIndices.push(closestIndex);
+                if (cursorLoopIndices[i] > 0) {
+                    // Decrement the index. The previous group may also have a role on the next slider.
+                    --cursorLoopIndices[i];
+                }
+            }
+            const cursorIndex = closestDistances.indexOf(Math.min(...closestDistances));
+            const closestDistance = closestDistances[cursorIndex];
+            if (closestDistance > acceptableRadius / 2) {
+                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
+                continue;
+            }
+            const group = this.data.cursorMovement[cursorIndex].occurrenceGroups[closestGroupIndices[cursorIndex]];
+            let isCheesed = false;
+            // Track cursor movement to see if it lands on every tick.
+            let occurrenceLoopIndex = 1;
+            const { allOccurrences } = group;
+            for (let i = 1; i < object.nestedHitObjects.length; ++i) {
+                if (isCheesed) {
+                    break;
+                }
+                const tickWasHit = objectData.tickset[i - 1];
+                if (!tickWasHit) {
+                    continue;
+                }
+                const nestedObject = object.nestedHitObjects[i];
+                const nestedPosition = nestedObject.stackedPosition;
+                while (occurrenceLoopIndex < allOccurrences.length &&
+                    allOccurrences[occurrenceLoopIndex].time <
+                        nestedObject.startTime) {
+                    ++occurrenceLoopIndex;
+                }
+                if (occurrenceLoopIndex === allOccurrences.length) {
+                    continue;
+                }
+                const cursor = allOccurrences[occurrenceLoopIndex];
+                const prevCursor = allOccurrences[occurrenceLoopIndex - 1];
+                const currentPosition = this.getCursorPosition(cursor);
+                const prevPosition = this.getCursorPosition(prevCursor);
+                switch (cursor.id) {
+                    case exports.MovementType.move: {
+                        // Interpolate cursor position during nested object time.
+                        const t = (nestedObject.startTime - prevCursor.time) /
+                            (cursor.time - prevCursor.time);
+                        const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                        const distance = cursorPosition.getDistance(nestedPosition);
+                        isCheesed = distance > acceptableRadius;
+                        break;
+                    }
+                    case exports.MovementType.up:
+                        isCheesed =
+                            prevPosition.getDistance(nestedPosition) >
+                                acceptableRadius;
+                }
+            }
+            if (isCheesed) {
+                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
+            }
+        }
+        return cheesedDifficultyRatings;
+    }
+    /**
+     * Calculates the slider cheese penalty.
+     */
+    calculateSliderCheesePenalty(cheesedDifficultyRatings) {
+        const summedDifficultyRating = Math.min(1, cheesedDifficultyRatings.reduce((a, v) => a + v, 0));
+        return {
+            aimPenalty: Math.max(this.difficultyAttributes.sliderFactor, Math.pow(1 -
+                summedDifficultyRating *
+                    this.difficultyAttributes.sliderFactor, 2)),
+            flashlightPenalty: Math.max(this.difficultyAttributes.flashlightSliderFactor, Math.pow(1 -
+                summedDifficultyRating *
+                    this.difficultyAttributes.flashlightSliderFactor, 2)),
+        };
+    }
+    getCursorPosition(cursor) {
+        if (this.isHardRock) {
+            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
+        }
+        return cursor.position;
+    }
+}
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -742,7 +958,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 /**
- * Utility to check whether relevant sliders in a beatmap are cheesed.
+ * Utility to check whether relevant sliders in a beatmap are cheesed for live scores.
  */
 class SliderCheeseChecker {
     /**
@@ -765,12 +981,10 @@ class SliderCheeseChecker {
     check() {
         if (this.difficultyAttributes.difficultSliders.length === 0 ||
             (this.difficultyAttributes.sliderFactor === 1 &&
-                this.difficultyAttributes.flashlightSliderFactor === 1 &&
-                this.difficultyAttributes.visualSliderFactor === 1)) {
+                this.difficultyAttributes.flashlightSliderFactor === 1)) {
             return {
                 aimPenalty: 1,
                 flashlightPenalty: 1,
-                visualPenalty: 1,
             };
         }
         const cheesedDifficultyRatings = this.checkSliderCheesing();
@@ -949,9 +1163,6 @@ class SliderCheeseChecker {
             flashlightPenalty: Math.max(this.difficultyAttributes.flashlightSliderFactor, Math.pow(1 -
                 summedDifficultyRating *
                     this.difficultyAttributes.flashlightSliderFactor, 2)),
-            visualPenalty: Math.max(this.difficultyAttributes.visualSliderFactor, Math.pow(1 -
-                summedDifficultyRating *
-                    this.difficultyAttributes.visualSliderFactor, 2)),
         };
     }
     getCursorPosition(cursor) {
@@ -1494,7 +1705,7 @@ class TwoHandChecker {
         //     );
         // }
         return {
-            is2Hand: 0 > this.attributes.aimNoteCount * 0.15,
+            is2Hand: false, // 0 > this.attributes.aimNoteCount * 0.15,
             twoHandedNoteCount: 0,
         };
     }
@@ -2076,7 +2287,6 @@ class ReplayAnalyzer {
         this.sliderCheesePenalty = {
             aimPenalty: 1,
             flashlightPenalty: 1,
-            visualPenalty: 1,
         };
         /**
          * Whether this replay has been checked against 3 finger usage.
@@ -2342,7 +2552,9 @@ class ReplayAnalyzer {
             return;
         }
         (_a = this.playableBeatmap) !== null && _a !== void 0 ? _a : (this.playableBeatmap = this.constructPlayableBeatmap());
-        const sliderCheeseChecker = new SliderCheeseChecker(this.playableBeatmap, this.data, this.difficultyAttributes);
+        const sliderCheeseChecker = this.difficultyAttributes.mode === "rebalance"
+            ? new RebalanceSliderCheeseChecker(this.playableBeatmap, this.data, this.difficultyAttributes)
+            : new SliderCheeseChecker(this.playableBeatmap, this.data, this.difficultyAttributes);
         this.sliderCheesePenalty = sliderCheeseChecker.check();
         this.hasBeenCheckedForSliderCheesing = true;
     }
@@ -2725,6 +2937,7 @@ class ReplayObjectData {
 exports.CursorData = CursorData;
 exports.CursorOccurrence = CursorOccurrence;
 exports.CursorOccurrenceGroup = CursorOccurrenceGroup;
+exports.RebalanceSliderCheeseChecker = RebalanceSliderCheeseChecker;
 exports.RebalanceThreeFingerChecker = RebalanceThreeFingerChecker;
 exports.ReplayAnalyzer = ReplayAnalyzer;
 exports.ReplayData = ReplayData;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-droid-replay-analyzer",
-    "version": "4.0.0-beta.76",
+    "version": "4.0.0-beta.78",
     "description": "A replay analyzer for analyzing osu!droid replay files.",
     "keywords": [
         "osu",
@@ -34,9 +34,9 @@
         "url": "https://github.com/Rian8337/osu-droid-module/issues"
     },
     "dependencies": {
-        "@rian8337/osu-base": "^4.0.0-beta.74",
-        "@rian8337/osu-difficulty-calculator": "^4.0.0-beta.76",
-        "@rian8337/osu-rebalance-difficulty-calculator": "^4.0.0-beta.76",
+        "@rian8337/osu-base": "^4.0.0-beta.78",
+        "@rian8337/osu-difficulty-calculator": "^4.0.0-beta.78",
+        "@rian8337/osu-rebalance-difficulty-calculator": "^4.0.0-beta.78",
         "java-deserialization": "^0.1.0",
         "unzipper": "^0.10.11"
     },
@@ -46,5 +46,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "d843f2cf65e2e44c87654a2be675d6ed925193ea"
+    "gitHead": "9b8c41ad3aeb0b98cb0818c9169ad3ad4e98b95e"
 }

package/typings/index.d.ts

@@ -720,10 +720,48 @@ interface SliderCheeseInformation {
      * The value used to penalize the flashlight performance value, from 0 to 1.
      */
     flashlightPenalty: number;
+}
+
+/**
+ * Utility to check whether relevant sliders in a beatmap are cheesed for rebalance scores..
+ */
+declare class RebalanceSliderCheeseChecker {
+    /**
+     * The beatmap that is being analyzed.
+     */
+    readonly beatmap: DroidPlayableBeatmap;
+    /**
+     * The data of the replay.
+     */
+    readonly data: ReplayData;
+    /**
+     * The difficulty attributes of the beatmap.
+     */
+    readonly difficultyAttributes: IExtendedDroidDifficultyAttributes;
+    /**
+     * The 50 osu!droid hit window of the analyzed beatmap.
+     */
+    private readonly hitWindow50;
+    private readonly isHardRock;
+    /**
+     * @param beatmap The beatmap to analyze.
+     * @param data The data of the replay.
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
+     */
+    constructor(beatmap: DroidPlayableBeatmap, data: ReplayData, difficultyAttributes: IExtendedDroidDifficultyAttributes);
+    /**
+     * Checks if relevant sliders in the given beatmap was cheesed.
+     */
+    check(): SliderCheeseInformation;
+    /**
+     * Checks for sliders that were cheesed.
+     */
+    private checkSliderCheesing;
     /**
-     * The value used to penalize the visual performance value, from 0 to 1.
+     * Calculates the slider cheese penalty.
      */
-    visualPenalty: number;
+    private calculateSliderCheesePenalty;
+    private getCursorPosition;
 }
 
 /**
@@ -919,7 +957,7 @@ declare class ReplayAnalyzer {
 }
 
 /**
- * Utility to check whether relevant sliders in a beatmap are cheesed.
+ * Utility to check whether relevant sliders in a beatmap are cheesed for live scores.
  */
 declare class SliderCheeseChecker {
     /**
@@ -933,7 +971,7 @@ declare class SliderCheeseChecker {
     /**
      * The difficulty attributes of the beatmap.
      */
-    readonly difficultyAttributes: IExtendedDroidDifficultyAttributes$1 | IExtendedDroidDifficultyAttributes;
+    readonly difficultyAttributes: IExtendedDroidDifficultyAttributes$1;
     /**
      * The 50 osu!droid hit window of the analyzed beatmap.
      */
@@ -944,7 +982,7 @@ declare class SliderCheeseChecker {
      * @param data The data of the replay.
      * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
-    constructor(beatmap: DroidPlayableBeatmap, data: ReplayData, difficultyAttributes: IExtendedDroidDifficultyAttributes$1 | IExtendedDroidDifficultyAttributes);
+    constructor(beatmap: DroidPlayableBeatmap, data: ReplayData, difficultyAttributes: IExtendedDroidDifficultyAttributes$1);
     /**
      * Checks if relevant sliders in the given beatmap was cheesed.
      */
@@ -1161,4 +1199,4 @@ declare class TwoHandChecker {
     private getCursorPosition;
 }
 
-export { CursorData, type CursorInformation, CursorOccurrence, CursorOccurrenceGroup, type ExportedReplayJSON, type ExportedReplayJSONDataV1, type ExportedReplayJSONDataV2, type ExportedReplayJSONDataV3, type ExportedReplayJSONV1, type ExportedReplayJSONV2, type ExportedReplayJSONV3, type HitErrorInformation, HitResult, MovementType, RebalanceThreeFingerChecker, ReplayAnalyzer, ReplayData, ReplayObjectData, ReplayV3Data, SliderCheeseChecker, type SliderCheeseInformation, type SliderHitInformation, type SliderNestedHitObjectInformation, ThreeFingerChecker, type ThreeFingerInformation, TwoHandChecker, type TwoHandInformation };
+export { CursorData, type CursorInformation, CursorOccurrence, CursorOccurrenceGroup, type ExportedReplayJSON, type ExportedReplayJSONDataV1, type ExportedReplayJSONDataV2, type ExportedReplayJSONDataV3, type ExportedReplayJSONV1, type ExportedReplayJSONV2, type ExportedReplayJSONV3, type HitErrorInformation, HitResult, MovementType, RebalanceSliderCheeseChecker, RebalanceThreeFingerChecker, ReplayAnalyzer, ReplayData, ReplayObjectData, ReplayV3Data, SliderCheeseChecker, type SliderCheeseInformation, type SliderHitInformation, type SliderNestedHitObjectInformation, ThreeFingerChecker, type ThreeFingerInformation, TwoHandChecker, type TwoHandInformation };