@rian8337/osu-difficulty-calculator 4.0.0-beta.24 → 4.0.0-beta.26

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.24",
+    "version": "4.0.0-beta.26",
     "description": "A module for calculating osu!standard beatmap difficulty and performance value with respect to the current difficulty and performance algorithm.",
     "keywords": [
         "osu",
@@ -33,10 +33,10 @@
         "url": "https://github.com/Rian8337/osu-droid-module/issues"
     },
     "dependencies": {
-        "@rian8337/osu-base": "^4.0.0-beta.24"
+        "@rian8337/osu-base": "^4.0.0-beta.26"
     },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "b567d54f6f8553aeaf56acb8a0b3741c3920b72b"
+    "gitHead": "1c353ee9455d80a5ca8358762f107899d64f1d5e"
 }

package/typings/index.d.ts

@@ -1,4 +1,4 @@
-import { Mod, PlaceableHitObject, Modes, Beatmap, DifficultyStatisticsCalculatorResult, Accuracy } from '@rian8337/osu-base';
+import { Mod, PlaceableHitObject, Modes, Beatmap, Accuracy } from '@rian8337/osu-base';
 
 /**
  * An evaluator for calculating aim skill.
@@ -62,12 +62,6 @@ interface DifficultyAttributes {
      * The overall clock rate that was applied to the beatmap.
      */
     clockRate: number;
-    /**
-     * The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
-     *
-     * Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
-     */
-    approachRate: number;
     /**
      * The perceived overall difficulty inclusive of rate-adjusting mods (DT/HT/etc), based on osu!standard judgement.
      *
@@ -191,6 +185,10 @@ declare abstract class DifficultyHitObject {
      * Adjusted end time of the hitobject, taking speed multiplier into account.
      */
     readonly endTime: number;
+    /**
+     * The full great window of the hitobject.
+     */
+    readonly fullGreatWindow: number;
     /**
      * Other hitobjects in the beatmap, including this hitobject.
      */
@@ -199,7 +197,10 @@ declare abstract class DifficultyHitObject {
     protected readonly normalizedRadius = 50;
     protected readonly maximumSliderRadius: number;
     protected readonly assumedSliderRadius: number;
-    protected readonly minDeltaTime = 25;
+    /**
+     * The lowest possible delta time value.
+     */
+    static readonly minDeltaTime = 25;
     private readonly lastObject;
     private readonly lastLastObject;
     /**
@@ -211,8 +212,9 @@ declare abstract class DifficultyHitObject {
      * @param lastLastObject The hitobject before the last hitobject.
      * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
      * @param clockRate The clock rate of the beatmap.
+     * @param greatWindow The great window of the hitobject.
      */
-    protected constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number);
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, greatWindow: number);
     /**
      * Computes the properties of this hitobject.
      *
@@ -250,6 +252,13 @@ declare abstract class DifficultyHitObject {
      * @returns The opacity of the hitobject at the given time.
      */
     opacityAt(time: number, isHidden: boolean): number;
+    /**
+     * How possible is it to doubletap this object together with the next one and get perfect
+     * judgement in range from 0 to 1.
+     *
+     * A value closer to 1 indicates a higher possibility.
+     */
+    get doubletapness(): number;
     protected abstract get scalingFactor(): number;
     protected setDistances(clockRate: number): void;
     private calculateSliderCursorPosition;
@@ -312,7 +321,11 @@ declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObje
     /**
      * The difficulty objects of the beatmap.
      */
-    readonly objects: THitObject[];
+    private _objects;
+    /**
+     * The difficulty objects of the beatmap.
+     */
+    get objects(): readonly THitObject[];
     /**
      * The modifications applied.
      */
@@ -321,10 +334,6 @@ declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObje
      * The total star rating of the beatmap.
      */
     get total(): number;
-    /**
-     * The difficulty statistics of the beatmap after modifications are applied.
-     */
-    difficultyStatistics: DifficultyStatisticsCalculatorResult<number, number, number, number>;
     /**
      * The strain peaks of various calculated difficulties.
      */
@@ -342,7 +351,7 @@ declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObje
     /**
      * Constructs a new instance of the calculator.
      *
-     * @param beatmap The beatmap to calculate. This beatmap will be deep-cloned to prevent reference changes.
+     * @param beatmap The beatmap to calculate.
      */
     constructor(beatmap: Beatmap);
     /**
@@ -364,16 +373,10 @@ declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObje
     /**
      * Generates difficulty hitobjects for this calculator.
      *
-     * @param convertedBeatmap The beatmap to generate difficulty hitobjects from.
-     */
-    protected abstract generateDifficultyHitObjects(convertedBeatmap: Beatmap): THitObject[];
-    /**
-     * Computes the difficulty statistics of the original beatmap with respect to the used options.
-     *
-     * @param options The options to use for the difficulty statistics calculation.
-     * @returns The computed difficulty statistics.
+     * @param beatmap The beatmap to generate difficulty hitobjects from.
+     * @param clockRate The clock rate of the beatmap.
      */
-    protected abstract computeDifficultyStatistics(options?: DifficultyCalculationOptions): DifficultyStatisticsCalculatorResult<number, number, number, number>;
+    protected abstract generateDifficultyHitObjects(beatmap: Beatmap, clockRate: number): THitObject[];
     /**
      * Calculates the skills provided.
      *
@@ -398,8 +401,11 @@ declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObje
     protected abstract createSkills(): Skill[];
     /**
      * Populates the stored difficulty attributes with necessary data.
+     *
+     * @param beatmap The beatmap to populate the attributes with.
+     * @param clockRate The clock rate of the beatmap.
      */
-    protected populateDifficultyAttributes(): void;
+    protected populateDifficultyAttributes(beatmap: Beatmap, clockRate: number): void;
     /**
      * Calculates the star rating value of a difficulty.
      *
@@ -521,6 +527,7 @@ declare abstract class DroidSkill extends StrainSkill {
      * The strains of hitobjects.
      */
     get objectStrains(): readonly number[];
+    private difficulty;
     /**
      * Returns the number of strains weighed against the top strain.
      *
@@ -599,9 +606,9 @@ declare class DroidDifficultyHitObject extends DifficultyHitObject {
      * @param lastLastObject The hitobject before the last hitobject.
      * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
      * @param clockRate The clock rate of the beatmap.
-     * @param isForceAR Whether force AR is enabled.
+     * @param greatWindow The great window of the hitobject.
      */
-    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, isForceAR: boolean);
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, greatWindow: number);
     computeProperties(clockRate: number, hitObjects: readonly PlaceableHitObject[]): void;
     /**
      * Determines whether this hitobject is considered overlapping with the hitobject before it.
@@ -609,6 +616,9 @@ declare class DroidDifficultyHitObject extends DifficultyHitObject {
      * Keep in mind that "overlapping" in this case is overlapping to the point where both hitobjects
      * can be hit with just a single tap in osu!droid.
      *
+     * In the case of sliders, it is considered overlapping if all nested hitobjects can be hit with
+     * one aim motion.
+     *
      * @param considerDistance Whether to consider the distance between both hitobjects.
      * @returns Whether the hitobject is considered overlapping.
      */
@@ -841,8 +851,7 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidDiffic
     calculateTotal(): void;
     calculateAll(): void;
     toString(): string;
-    protected generateDifficultyHitObjects(convertedBeatmap: Beatmap): DroidDifficultyHitObject[];
-    protected computeDifficultyStatistics(options?: DroidDifficultyCalculationOptions): DifficultyStatisticsCalculatorResult<number, number, number, number>;
+    protected generateDifficultyHitObjects(beatmap: Beatmap, clockRate: number): DroidDifficultyHitObject[];
     protected createSkills(): DroidSkill[];
     /**
      * Called after aim skill calculation.
@@ -1243,36 +1252,27 @@ declare class DroidRhythm extends DroidSkill {
     protected readonly starsPerDouble = 1.75;
     private currentRhythmStrain;
     private currentRhythmMultiplier;
-    private readonly hitWindow;
-    constructor(mods: Mod[], overallDifficulty: number);
     protected strainValueAt(current: DroidDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
     protected getObjectStrain(): number;
     protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
-/**
- * An evaluator for calculating rhythm skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-declare abstract class RhythmEvaluator {
-    protected static readonly rhythmMultiplier: number;
-    protected static readonly historyTimeMax: number;
-}
-
 /**
  * An evaluator for calculating osu!droid Rhythm skill.
  */
-declare abstract class DroidRhythmEvaluator extends RhythmEvaluator {
+declare abstract class DroidRhythmEvaluator {
+    private static readonly historyTimeMax;
+    private static readonly historyObjectsMax;
+    private static readonly rhythmOverallMultiplier;
+    private static readonly rhythmRatioMultiplier;
     /**
      * Calculates a rhythm multiplier for the difficulty of the tap associated
      * with historic data of the current object.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
      */
-    static evaluateDifficultyOf(current: DroidDifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject): number;
 }
 
 /**
@@ -1286,7 +1286,6 @@ declare class DroidTap extends DroidSkill {
     private currentTapStrain;
     private currentRhythmMultiplier;
     private readonly skillMultiplier;
-    private readonly greatWindow;
     private readonly considerCheesability;
     private readonly strainTimeCap?;
     private readonly _objectDeltaTimes;
@@ -1294,7 +1293,7 @@ declare class DroidTap extends DroidSkill {
      * The delta time of hitobjects.
      */
     get objectDeltaTimes(): readonly number[];
-    constructor(mods: Mod[], overallDifficulty: number, considerCheesability: boolean, strainTimeCap?: number);
+    constructor(mods: Mod[], considerCheesability: boolean, strainTimeCap?: number);
     /**
      * The amount of notes that are relevant to the difficulty.
      */
@@ -1338,7 +1337,7 @@ declare abstract class DroidTapEvaluator extends SpeedEvaluator {
      * @param considerCheesability Whether to consider cheesability.
      * @param strainTimeCap The strain time to cap the object's strain time to.
      */
-    static evaluateDifficultyOf(current: DroidDifficultyHitObject, greatWindow: number, considerCheesability: boolean, strainTimeCap?: number): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, considerCheesability: boolean, strainTimeCap?: number): number;
 }
 
 /**
@@ -1420,17 +1419,6 @@ declare class OsuDifficultyHitObject extends DifficultyHitObject {
     private readonly radiusBuffThreshold;
     protected readonly mode = Modes.osu;
     protected get scalingFactor(): number;
-    /**
-     * Note: You **must** call `computeProperties` at some point due to how TypeScript handles
-     * overridden properties (see [this](https://github.com/microsoft/TypeScript/issues/1617) GitHub issue).
-     *
-     * @param object The underlying hitobject.
-     * @param lastObject The hitobject before this hitobject.
-     * @param lastLastObject The hitobject before the last hitobject.
-     * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
-     * @param clockRate The clock rate of the beatmap.
-     */
-    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number);
 }
 
 /**
@@ -1475,6 +1463,12 @@ declare abstract class OsuAimEvaluator extends AimEvaluator {
  * Holds data that can be used to calculate osu!standard performance points.
  */
 interface OsuDifficultyAttributes extends DifficultyAttributes {
+    /**
+     * The perceived approach rate inclusive of rate-adjusting mods (DT/HT/etc).
+     *
+     * Rate-adjusting mods don't directly affect the approach rate difficulty value, but have a perceived effect as a result of adjusting audio timing.
+     */
+    approachRate: number;
     /**
      * The difficulty corresponding to the speed skill.
      */
@@ -1516,9 +1510,9 @@ declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuDifficulty
     calculateTotal(): void;
     calculateAll(): void;
     toString(): string;
-    protected generateDifficultyHitObjects(convertedBeatmap: Beatmap): OsuDifficultyHitObject[];
-    protected computeDifficultyStatistics(options?: DifficultyCalculationOptions): DifficultyStatisticsCalculatorResult<number, number, number, number>;
+    protected generateDifficultyHitObjects(beatmap: Beatmap, clockRate: number): OsuDifficultyHitObject[];
     protected createSkills(): OsuSkill[];
+    protected populateDifficultyAttributes(beatmap: Beatmap, clockRate: number): void;
     /**
      * Called after aim skill calculation.
      *
@@ -1626,7 +1620,9 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<OsuDifficul
 /**
  * An evaluator for calculating osu!standard Rhythm skill.
  */
-declare abstract class OsuRhythmEvaluator extends RhythmEvaluator {
+declare abstract class OsuRhythmEvaluator {
+    private static readonly rhythmMultiplier;
+    private static readonly historyTimeMax;
     /**
      * Calculates a rhythm multiplier for the difficulty of the tap associated
      * with historic data of the current object.
@@ -1634,7 +1630,7 @@ declare abstract class OsuRhythmEvaluator extends RhythmEvaluator {
      * @param current The current object.
      * @param greatWindow The great hit window of the current object.
      */
-    static evaluateDifficultyOf(current: OsuDifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
 }
 
 /**
@@ -1649,8 +1645,6 @@ declare class OsuSpeed extends OsuSkill {
     private currentSpeedStrain;
     private currentRhythm;
     private readonly skillMultiplier;
-    private readonly greatWindow;
-    constructor(mods: Mod[], overallDifficulty: number);
     /**
      * @param current The hitobject to calculate.
      */
@@ -1678,9 +1672,8 @@ declare abstract class OsuSpeedEvaluator extends SpeedEvaluator {
      * - and how easily they can be cheesed.
      *
      * @param current The current object.
-     * @param greatWindow The great hit window of the current object.
      */
-    static evaluateDifficultyOf(current: OsuDifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
 }
 
-export { AimEvaluator, type CacheableDifficultyAttributes, type DifficultSlider, type DifficultyAttributes, type DifficultyCalculationOptions, DifficultyCalculator, DifficultyHitObject, DroidAim, DroidAimEvaluator, type DroidDifficultyAttributes, type DroidDifficultyCalculationOptions, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, type ExtendedDroidDifficultyAttributes, FlashlightEvaluator, type HighStrainSection, OsuAim, OsuAimEvaluator, type OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, type PerformanceCalculationOptions, PerformanceCalculator, RhythmEvaluator, SpeedEvaluator, type StrainPeaks };
+export { AimEvaluator, type CacheableDifficultyAttributes, type DifficultSlider, type DifficultyAttributes, type DifficultyCalculationOptions, DifficultyCalculator, DifficultyHitObject, DroidAim, DroidAimEvaluator, type DroidDifficultyAttributes, type DroidDifficultyCalculationOptions, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, type ExtendedDroidDifficultyAttributes, FlashlightEvaluator, type HighStrainSection, OsuAim, OsuAimEvaluator, type OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, type PerformanceCalculationOptions, PerformanceCalculator, SpeedEvaluator, type StrainPeaks };