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

package/dist/index.js

@@ -963,7 +963,7 @@ class SliderCheeseChecker {
 }
 
 /**
- * Utility to check whether or not a beatmap is three-fingered for rebalance scores.
+ * Utility to check whether or not a beatmap is three-fingered for live scores.
  */
 class ThreeFingerChecker {
     /**
@@ -1026,9 +1026,6 @@ class ThreeFingerChecker {
         }
         this.getAccurateBreakPoints();
         this.filterCursorInstances();
-        if (this.downCursorInstances.filter((v) => v.length > 0).length <= 3) {
-            return { is3Finger: false, penalty: 1 };
-        }
         this.getBeatmapSections();
         this.calculateNerfFactors();
         const finalPenalty = this.calculateFinalPenalty();
@@ -2129,7 +2126,7 @@ class ReplayAnalyzer {
     /**
      * Gets hit error information of the replay.
      *
-     * `analyze()` must be called before calling this.
+     * `analyze()` must be called before calling this, and `beatmap` must be defined.
      */
     calculateHitError() {
         var _a, _b;
@@ -2180,6 +2177,124 @@ class ReplayAnalyzer {
             unstableRate: osuBase.MathUtils.calculateStandardDeviation(accuracies) * 10,
         };
     }
+    /**
+     * Obtains the amount of slider ticks and ends hit in the replay.
+     *
+     * This requires `analyze()` to be called first and `beatmap` to be defined.
+     *
+     * @returns Slider hit information or `null` if the replay has not been analyzed or the beatmap is not defined.
+     */
+    obtainSliderHitInformation() {
+        const { data, beatmap } = this;
+        if (!data || !beatmap) {
+            return null;
+        }
+        const sliderInformation = {
+            tick: { obtained: 0, total: beatmap.hitObjects.sliderTicks },
+            end: { obtained: 0, total: beatmap.hitObjects.sliders },
+        };
+        for (let i = 0; i < data.hitObjectData.length; ++i) {
+            const object = beatmap.hitObjects.objects[i];
+            const objectData = data.hitObjectData[i];
+            if (objectData.result === exports.HitResult.miss ||
+                !(object instanceof osuBase.Slider)) {
+                continue;
+            }
+            // Exclude the head circle.
+            for (let j = 1; j < object.nestedHitObjects.length; ++j) {
+                const nested = object.nestedHitObjects[j];
+                if (!objectData.tickset[j - 1]) {
+                    continue;
+                }
+                if (nested instanceof osuBase.SliderTick) {
+                    ++sliderInformation.tick.obtained;
+                }
+                else if (nested instanceof osuBase.SliderTail) {
+                    ++sliderInformation.end.obtained;
+                }
+            }
+        }
+        return sliderInformation;
+    }
+    /**
+     * Simulates a hit window for the replay.
+     *
+     * This does not account for required spins in a spinner.
+     *
+     * Requires `analyze()` to be called first and `beatmap` to be defined.
+     *
+     * @param hitWindow The hit window to simulate.
+     * @returns The accuracy of the replay based on the hit window, or `null` if the replay has not been analyzed or the beatmap is not defined.
+     */
+    simulateHitWindow(hitWindow) {
+        const { data, beatmap } = this;
+        if (!data || !beatmap) {
+            return null;
+        }
+        const accuracy = new osuBase.Accuracy({ n300: 0, n100: 0, n50: 0, nmiss: 0 });
+        for (let i = 0; i < data.hitObjectData.length; ++i) {
+            const object = beatmap.hitObjects.objects[i];
+            const objectData = data.hitObjectData[i];
+            const hitAccuracy = Math.abs(objectData.accuracy);
+            let { result } = objectData;
+            if (object instanceof osuBase.Circle) {
+                if (hitAccuracy <= hitWindow.greatWindow) {
+                    result = exports.HitResult.great;
+                }
+                else if (hitAccuracy <= hitWindow.okWindow) {
+                    result = exports.HitResult.good;
+                }
+                else if (hitAccuracy <= hitWindow.mehWindow) {
+                    result = exports.HitResult.meh;
+                }
+                else {
+                    result = exports.HitResult.miss;
+                }
+            }
+            else if (object instanceof osuBase.Slider) {
+                if (hitAccuracy <=
+                    Math.min(hitWindow.mehWindow, object.duration)) {
+                    let ticksObtained = 1;
+                    for (let j = 1; j < object.nestedHitObjects.length; ++j) {
+                        if (objectData.tickset[j - 1]) {
+                            ++ticksObtained;
+                        }
+                    }
+                    if (ticksObtained === object.nestedHitObjects.length) {
+                        result = exports.HitResult.great;
+                    }
+                    else if (ticksObtained >=
+                        Math.trunc(object.nestedHitObjects.length / 2)) {
+                        result = exports.HitResult.good;
+                    }
+                    else if (ticksObtained > 0) {
+                        result = exports.HitResult.meh;
+                    }
+                    else {
+                        result = exports.HitResult.miss;
+                    }
+                }
+                else {
+                    result = exports.HitResult.miss;
+                }
+            }
+            switch (result) {
+                case exports.HitResult.miss:
+                    ++accuracy.nmiss;
+                    break;
+                case exports.HitResult.meh:
+                    ++accuracy.n50;
+                    break;
+                case exports.HitResult.good:
+                    ++accuracy.n100;
+                    break;
+                case exports.HitResult.great:
+                    ++accuracy.n300;
+                    break;
+            }
+        }
+        return accuracy;
+    }
     /**
      * Checks if a play is using 3 fingers.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-droid-replay-analyzer",
-    "version": "4.0.0-beta.74",
+    "version": "4.0.0-beta.76",
     "description": "A replay analyzer for analyzing osu!droid replay files.",
     "keywords": [
         "osu",
@@ -35,8 +35,8 @@
     },
     "dependencies": {
         "@rian8337/osu-base": "^4.0.0-beta.74",
-        "@rian8337/osu-difficulty-calculator": "^4.0.0-beta.74",
-        "@rian8337/osu-rebalance-difficulty-calculator": "^4.0.0-beta.74",
+        "@rian8337/osu-difficulty-calculator": "^4.0.0-beta.76",
+        "@rian8337/osu-rebalance-difficulty-calculator": "^4.0.0-beta.76",
         "java-deserialization": "^0.1.0",
         "unzipper": "^0.10.11"
     },
@@ -46,5 +46,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "00abc82040e820ccff8fcad7ee77d7e7d8031717"
+    "gitHead": "d843f2cf65e2e44c87654a2be675d6ed925193ea"
 }

package/typings/index.d.ts

@@ -1,4 +1,4 @@
-import { Vector2, Accuracy, ScoreRank, ModMap, DroidPlayableBeatmap, Beatmap } from '@rian8337/osu-base';
+import { Vector2, Accuracy, ScoreRank, ModMap, DroidPlayableBeatmap, Beatmap, HitWindow } from '@rian8337/osu-base';
 import { IExtendedDroidDifficultyAttributes as IExtendedDroidDifficultyAttributes$1 } from '@rian8337/osu-difficulty-calculator';
 import { IExtendedDroidDifficultyAttributes } from '@rian8337/osu-rebalance-difficulty-calculator';
 
@@ -726,6 +726,33 @@ interface SliderCheeseInformation {
     visualPenalty: number;
 }
 
+/**
+ * Represents hit information about sliders in a beatmap.
+ */
+interface SliderHitInformation {
+    /**
+     * Hit information of slider ticks.
+     */
+    readonly tick: SliderNestedHitObjectInformation;
+    /**
+     * hit information of slider ends.
+     */
+    readonly end: SliderNestedHitObjectInformation;
+}
+/**
+ * Hit information of a specific nested hit object.
+ */
+interface SliderNestedHitObjectInformation {
+    /**
+     * The amount of the nested hit objects that were obtained.
+     */
+    obtained: number;
+    /**
+     * The amount of the nested hit objects in the beatmap.
+     */
+    readonly total: number;
+}
+
 interface HitErrorInformation {
     negativeAvg: number;
     positiveAvg: number;
@@ -822,9 +849,28 @@ declare class ReplayAnalyzer {
     /**
      * Gets hit error information of the replay.
      *
-     * `analyze()` must be called before calling this.
+     * `analyze()` must be called before calling this, and `beatmap` must be defined.
      */
     calculateHitError(): HitErrorInformation | null;
+    /**
+     * Obtains the amount of slider ticks and ends hit in the replay.
+     *
+     * This requires `analyze()` to be called first and `beatmap` to be defined.
+     *
+     * @returns Slider hit information or `null` if the replay has not been analyzed or the beatmap is not defined.
+     */
+    obtainSliderHitInformation(): SliderHitInformation | null;
+    /**
+     * Simulates a hit window for the replay.
+     *
+     * This does not account for required spins in a spinner.
+     *
+     * Requires `analyze()` to be called first and `beatmap` to be defined.
+     *
+     * @param hitWindow The hit window to simulate.
+     * @returns The accuracy of the replay based on the hit window, or `null` if the replay has not been analyzed or the beatmap is not defined.
+     */
+    simulateHitWindow(hitWindow: HitWindow): Accuracy | null;
     /**
      * Checks if a play is using 3 fingers.
      *
@@ -915,7 +961,7 @@ declare class SliderCheeseChecker {
 }
 
 /**
- * Utility to check whether or not a beatmap is three-fingered for rebalance scores.
+ * Utility to check whether or not a beatmap is three-fingered for live scores.
  */
 declare class ThreeFingerChecker {
     /**
@@ -1115,4 +1161,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, 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, RebalanceThreeFingerChecker, ReplayAnalyzer, ReplayData, ReplayObjectData, ReplayV3Data, SliderCheeseChecker, type SliderCheeseInformation, type SliderHitInformation, type SliderNestedHitObjectInformation, ThreeFingerChecker, type ThreeFingerInformation, TwoHandChecker, type TwoHandInformation };