@rian8337/osu-difficulty-calculator 4.0.0-beta.4 → 4.0.0-beta.40

package/typings/index.d.ts

@@ -1,4 +1,4 @@
-import { MapStats, Mod, PlaceableHitObject, Modes, Beatmap, HitObject, Accuracy } from '@rian8337/osu-base';
+import { Mod, PlaceableHitObject, Modes, Beatmap, Accuracy } from '@rian8337/osu-base';
 
 /**
  * An evaluator for calculating aim skill.
@@ -20,16 +20,6 @@ declare abstract class AimEvaluator {
     protected static calculateAcuteAngleBonus(angle: number): number;
 }
 
-/**
- * The base of calculation options.
- */
-interface CalculationOptions {
-    /**
-     * Custom map statistics to apply custom speed multiplier as well as old statistics.
-     */
-    stats?: MapStats;
-}
-
 /**
  * Holds data that can be used to calculate performance points.
  */
@@ -69,11 +59,9 @@ interface DifficultyAttributes {
      */
     sliderFactor: 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.
+     * The overall clock rate that was applied to the beatmap.
      */
-    approachRate: number;
+    clockRate: number;
     /**
      * The perceived overall difficulty inclusive of rate-adjusting mods (DT/HT/etc), based on osu!standard judgement.
      *
@@ -92,22 +80,40 @@ interface DifficultyAttributes {
      * The number of spinners in the beatmap.
      */
     spinnerCount: number;
+    /**
+     * The amount of strains that are considered difficult with respect to the aim skill.
+     */
+    aimDifficultStrainCount: number;
 }
 
+/**
+ * Represents difficulty attributes that can be cached.
+ */
+type CacheableDifficultyAttributes<T extends DifficultyAttributes> = Omit<T, "mods"> & {
+    /**
+     * The mods which were applied to the beatmap.
+     */
+    mods: string;
+};
+
 /**
  * Represents options for difficulty calculation.
  */
-interface DifficultyCalculationOptions extends CalculationOptions {
+interface DifficultyCalculationOptions {
     /**
      * The modifications to apply.
      */
-    mods?: Mod[];
+    readonly mods?: Mod[];
+    /**
+     * The custom speed multiplier to apply. Defaults to 1.
+     */
+    readonly customSpeedMultiplier?: number;
 }
 
 /**
- * Represents an osu!standard hit object with difficulty calculation values.
+ * Represents a hit object with difficulty calculation values.
  */
-declare class DifficultyHitObject {
+declare abstract class DifficultyHitObject {
     /**
      * The underlying hitobject.
      */
@@ -117,19 +123,7 @@ declare class DifficultyHitObject {
      *
      * This is one less than the actual index of the hitobject in the beatmap.
      */
-    index: number;
-    /**
-     * The preempt time of the hitobject.
-     */
-    baseTimePreempt: number;
-    /**
-     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
-     */
-    timePreempt: number;
-    /**
-     * The fade in time of the hitobject.
-     */
-    timeFadeIn: number;
+    readonly index: number;
     /**
      * The aim strain generated by the hitobject if sliders are considered.
      */
@@ -138,41 +132,10 @@ declare class DifficultyHitObject {
      * The aim strain generated by the hitobject if sliders are not considered.
      */
     aimStrainWithoutSliders: number;
-    /**
-     * The tap strain generated by the hitobject.
-     *
-     * This is also used for osu!standard as opposed to "speed strain".
-     */
-    tapStrain: number;
-    /**
-     * The tap strain generated by the hitobject if `strainTime` isn't modified by
-     * OD. This is used in three-finger detection.
-     */
-    originalTapStrain: number;
     /**
      * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
      */
     rhythmMultiplier: number;
-    /**
-     * The rhythm strain generated by the hitobject.
-     */
-    rhythmStrain: number;
-    /**
-     * The flashlight strain generated by the hitobject if sliders are considered.
-     */
-    flashlightStrainWithSliders: number;
-    /**
-     * The flashlight strain generated by the hitobject if sliders are not considered.
-     */
-    flashlightStrainWithoutSliders: number;
-    /**
-     * The visual strain generated by the hitobject if sliders are considered.
-     */
-    visualStrainWithSliders: number;
-    /**
-     * The visual strain generated by the hitobject if sliders are not considered.
-     */
-    visualStrainWithoutSliders: number;
     /**
      * The normalized distance from the "lazy" end position of the previous hitobject to the start position of this hitobject.
      *
@@ -213,42 +176,55 @@ declare class DifficultyHitObject {
     /**
      * The amount of milliseconds elapsed between this hitobject and the last hitobject.
      */
-    deltaTime: number;
+    readonly deltaTime: number;
     /**
      * The amount of milliseconds elapsed since the start time of the previous hitobject, with a minimum of 25ms.
      */
-    strainTime: number;
+    readonly strainTime: number;
     /**
      * Adjusted start time of the hitobject, taking speed multiplier into account.
      */
-    startTime: number;
+    readonly startTime: number;
     /**
      * Adjusted end time of the hitobject, taking speed multiplier into account.
      */
-    endTime: number;
+    readonly endTime: number;
     /**
-     * The note density of the hitobject.
+     * The full great window of the hitobject.
      */
-    noteDensity: number;
+    readonly fullGreatWindow: number;
     /**
-     * The overlapping factor of the hitobject.
-     *
-     * This is used to scale visual skill.
+     * Other hitobjects in the beatmap, including this hitobject.
      */
-    overlappingFactor: number;
+    protected readonly hitObjects: readonly DifficultyHitObject[];
+    protected abstract readonly mode: Modes;
+    protected readonly normalizedRadius = 50;
+    protected readonly maximumSliderRadius: number;
+    protected readonly assumedSliderRadius: number;
     /**
-     * Adjusted velocity of the hitobject, taking speed multiplier into account.
+     * The lowest possible delta time value.
      */
-    velocity: number;
+    static readonly minDeltaTime = 25;
+    private readonly lastObject;
+    private readonly lastLastObject;
     /**
-     * Other hitobjects in the beatmap, including this hitobject.
+     * 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.
      */
-    private readonly hitObjects;
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number);
     /**
-     * @param object The underlying hitobject.
-     * @param hitObjects All difficulty hitobjects in the processed beatmap.
+     * Computes the properties of this hitobject.
+     *
+     * @param clockRate The clock rate of the beatmap.
+     * @param hitObjects The hitobjects in the beatmap.
      */
-    constructor(object: PlaceableHitObject, hitObjects: DifficultyHitObject[]);
+    computeProperties(clockRate: number, hitObjects: readonly PlaceableHitObject[]): void;
     /**
      * Gets the difficulty hitobject at a specific index with respect to the current
      * difficulty hitobject's index.
@@ -259,7 +235,7 @@ declare class DifficultyHitObject {
      * @returns The difficulty hitobject at the index with respect to the current
      * difficulty hitobject's index, `null` if the index is out of range.
      */
-    previous(backwardsIndex: number): DifficultyHitObject | null;
+    previous(backwardsIndex: number): this | null;
     /**
      * Gets the difficulty hitobject at a specific index with respect to the current
      * difficulty hitobject's index.
@@ -270,26 +246,48 @@ declare class DifficultyHitObject {
      * @returns The difficulty hitobject at the index with respect to the current
      * difficulty hitobject's index, `null` if the index is out of range.
      */
-    next(forwardsIndex: number): DifficultyHitObject | null;
+    next(forwardsIndex: number): this | null;
     /**
      * Calculates the opacity of the hitobject at a given time.
      *
      * @param time The time to calculate the hitobject's opacity at.
      * @param isHidden Whether Hidden mod is used.
-     * @param mode The gamemode to calculate the opacity for.
      * @returns The opacity of the hitobject at the given time.
      */
-    opacityAt(time: number, isHidden: boolean, mode: Modes): number;
+    opacityAt(time: number, isHidden: boolean): number;
     /**
-     * Determines whether this hitobject is considered overlapping with the hitobject before it.
+     * How possible is it to doubletap this object together with the next one and get perfect
+     * judgement in range from 0 to 1.
      *
-     * 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.
-     *
-     * @param considerDistance Whether to consider the distance between both hitobjects.
-     * @returns Whether the hitobject is considered overlapping.
+     * A value closer to 1 indicates a higher possibility.
      */
-    isOverlapping(considerDistance: boolean): boolean;
+    get doubletapness(): number;
+    protected abstract get scalingFactor(): number;
+    protected setDistances(clockRate: number): void;
+    private calculateSliderCursorPosition;
+    private getEndCursorPosition;
+}
+
+/**
+ * Represents the strain peaks of various calculated difficulties.
+ */
+interface StrainPeaks {
+    /**
+     * The strain peaks of aim difficulty if sliders are considered.
+     */
+    aimWithSliders: number[];
+    /**
+     * The strain peaks of aim difficulty if sliders are not considered.
+     */
+    aimWithoutSliders: number[];
+    /**
+     * The strain peaks of speed difficulty.
+     */
+    speed: number[];
+    /**
+     * The strain peaks of flashlight difficulty.
+     */
+    flashlight: number[];
 }
 
 /**
@@ -316,103 +314,9 @@ declare abstract class Skill {
 }
 
 /**
- * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
- * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
- */
-declare abstract class StrainSkill extends Skill {
-    /**
-     * The strain of currently calculated hitobject.
-     */
-    protected currentStrain: number;
-    /**
-     * The current section's strain peak.
-     */
-    protected currentSectionPeak: number;
-    /**
-     * Strain peaks are stored here.
-     */
-    readonly strainPeaks: number[];
-    /**
-     * The number of sections with the highest strains, which the peak strain reductions will apply to.
-     * This is done in order to decrease their impact on the overall difficulty of the map for this skill.
-     */
-    protected abstract readonly reducedSectionCount: number;
-    /**
-     * The baseline multiplier applied to the section with the biggest strain.
-     */
-    protected abstract readonly reducedSectionBaseline: number;
-    /**
-     * Strain values are multiplied by this number for the given skill. Used to balance the value of different skills between each other.
-     */
-    protected abstract readonly skillMultiplier: number;
-    /**
-     * Determines how quickly strain decays for the given skill.
-     *
-     * For example, a value of 0.15 indicates that strain decays to 15% of its original value in one second.
-     */
-    protected abstract readonly strainDecayBase: number;
-    private readonly sectionLength;
-    private currentSectionEnd;
-    private isFirstObject;
-    /**
-     * Calculates the strain value of a hitobject and stores the value in it. This value is affected by previously processed objects.
-     *
-     * @param current The hitobject to process.
-     */
-    process(current: DifficultyHitObject): void;
-    /**
-     * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
-     */
-    saveCurrentPeak(): void;
-    /**
-     * Calculates strain decay for a specified time frame.
-     *
-     * @param ms The time frame to calculate.
-     */
-    protected strainDecay(ms: number): number;
-    /**
-     * Calculates the strain value at a hitobject.
-     */
-    protected abstract strainValueAt(current: DifficultyHitObject): number;
-    /**
-     * Saves the current strain to a hitobject.
-     */
-    protected abstract saveToHitObject(current: DifficultyHitObject): void;
-    /**
-     * Sets the initial strain level for a new section.
-     *
-     * @param offset The beginning of the new section in milliseconds, adjusted by speed multiplier.
-     * @param current The current hitobject.
-     */
-    private startNewSectionFrom;
-}
-
-/**
- * Represents the strain peaks of various calculated difficulties.
+ * The base of a difficulty calculator.
  */
-interface StrainPeaks {
-    /**
-     * The strain peaks of aim difficulty if sliders are considered.
-     */
-    aimWithSliders: number[];
-    /**
-     * The strain peaks of aim difficulty if sliders are not considered.
-     */
-    aimWithoutSliders: number[];
-    /**
-     * The strain peaks of speed difficulty.
-     */
-    speed: number[];
-    /**
-     * The strain peaks of flashlight difficulty.
-     */
-    flashlight: number[];
-}
-
-/**
- * The base of difficulty calculators.
- */
-declare abstract class DifficultyCalculator {
+declare abstract class DifficultyCalculator<THitObject extends DifficultyHitObject, TAttributes extends DifficultyAttributes> {
     /**
      * The calculated beatmap.
      */
@@ -420,7 +324,11 @@ declare abstract class DifficultyCalculator {
     /**
      * The difficulty objects of the beatmap.
      */
-    readonly objects: DifficultyHitObject[];
+    private _objects;
+    /**
+     * The difficulty objects of the beatmap.
+     */
+    get objects(): readonly THitObject[];
     /**
      * The modifications applied.
      */
@@ -428,26 +336,25 @@ declare abstract class DifficultyCalculator {
     /**
      * The total star rating of the beatmap.
      */
-    total: number;
-    /**
-     * The map statistics of the beatmap after modifications are applied.
-     */
-    stats: MapStats;
+    get total(): number;
     /**
      * The strain peaks of various calculated difficulties.
      */
     readonly strainPeaks: StrainPeaks;
     /**
-     * Holds data that can be used to calculate performance points.
+     * The difficulty attributes that can be used to calculate performance points.
      */
-    abstract readonly attributes: DifficultyAttributes;
-    protected readonly sectionLength: number;
+    abstract readonly attributes: TAttributes;
+    /**
+     * The difficulty attributes that can be cached. It can also be used to calculate performance points.
+     */
+    abstract get cacheableAttributes(): CacheableDifficultyAttributes<TAttributes>;
     protected abstract readonly difficultyMultiplier: number;
     protected abstract readonly mode: Modes;
     /**
      * 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);
     /**
@@ -468,18 +375,17 @@ declare abstract class DifficultyCalculator {
     calculate(options?: DifficultyCalculationOptions): this;
     /**
      * Generates difficulty hitobjects for this calculator.
+     *
+     * @param beatmap The beatmap to generate difficulty hitobjects from.
+     * @param clockRate The clock rate of the beatmap.
      */
-    generateDifficultyHitObjects(): void;
-    /**
-     * Performs some pre-processing before proceeding with difficulty calculation.
-     */
-    protected preProcess(): void;
+    protected abstract generateDifficultyHitObjects(beatmap: Beatmap, clockRate: number): THitObject[];
     /**
      * Calculates the skills provided.
      *
      * @param skills The skills to calculate.
      */
-    protected calculateSkills(...skills: StrainSkill[]): void;
+    protected calculateSkills(...skills: Skill[]): void;
     /**
      * Calculates the total star rating of the beatmap and stores it in this instance.
      */
@@ -495,11 +401,21 @@ declare abstract class DifficultyCalculator {
     /**
      * Creates skills to be calculated.
      */
-    protected abstract createSkills(): StrainSkill[];
+    protected abstract createSkills(): Skill[];
+    /**
+     * Obtains the clock rate of the beatmap.
+     *
+     * @param options The options to obtain the clock rate with.
+     * @returns The clock rate of the beatmap.
+     */
+    protected calculateClockRate(options?: DifficultyCalculationOptions): number;
     /**
      * 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.
      *
@@ -507,128 +423,248 @@ declare abstract class DifficultyCalculator {
      */
     protected starValue(difficulty: number): number;
     /**
-     * Calculates the base performance value of a difficulty rating.
+     * Calculates the base performance value of a difficulty rating.
+     *
+     * @param rating The difficulty rating.
+     */
+    protected basePerformanceValue(rating: number): number;
+}
+
+/**
+ * Represents a slider that is considered difficult.
+ *
+ * This structure is a part of difficulty attributes and can be cached.
+ */
+interface DifficultSlider {
+    /**
+     * The index of the slider in the beatmap.
+     */
+    readonly index: number;
+    /**
+     * The difficulty rating of this slider compared to other sliders, based on the velocity of the slider.
+     *
+     * A value closer to 1 indicates that this slider is more difficult compared to most sliders.
+     *
+     * A value closer to 0 indicates that this slider is easier compared to most sliders.
+     */
+    readonly difficultyRating: number;
+}
+
+/**
+ * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
+ * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
+ */
+declare abstract class StrainSkill extends Skill {
+    /**
+     * Strain peaks are stored here.
+     */
+    readonly strainPeaks: number[];
+    /**
+     * The number of sections with the highest strains, which the peak strain reductions will apply to.
+     * This is done in order to decrease their impact on the overall difficulty of the map for this skill.
+     */
+    protected abstract readonly reducedSectionCount: number;
+    /**
+     * The baseline multiplier applied to the section with the biggest strain.
+     */
+    protected abstract readonly reducedSectionBaseline: number;
+    /**
+     * Determines how quickly strain decays for the given skill.
+     *
+     * For example, a value of 0.15 indicates that strain decays to 15% of its original value in one second.
+     */
+    protected abstract readonly strainDecayBase: number;
+    protected readonly _objectStrains: number[];
+    protected difficulty: number;
+    /**
+     * The strains of hitobjects.
+     */
+    get objectStrains(): readonly number[];
+    private readonly sectionLength;
+    private currentStrain;
+    private currentSectionPeak;
+    private currentSectionEnd;
+    process(current: DifficultyHitObject): void;
+    /**
+     * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
+     */
+    saveCurrentPeak(): void;
+    /**
+     * Returns the number of strains weighed against the top strain.
+     *
+     * The result is scaled by clock rate as it affects the total number of strains.
+     */
+    countDifficultStrains(): number;
+    /**
+     * Calculates strain decay for a specified time frame.
+     *
+     * @param ms The time frame to calculate.
+     */
+    protected strainDecay(ms: number): number;
+    /**
+     * Calculates the starting time of a strain section at an object.
+     *
+     * @param current The object at which the strain section starts.
+     * @returns The start time of the strain section.
+     */
+    protected calculateCurrentSectionStart(current: DifficultyHitObject): number;
+    /**
+     * Calculates the strain value at a hitobject.
+     *
+     * @param current The hitobject to calculate.
+     */
+    protected abstract strainValueAt(current: DifficultyHitObject): number;
+    /**
+     * Saves the current strain to a hitobject.
+     */
+    protected abstract saveToHitObject(current: DifficultyHitObject): void;
+    /**
+     * Retrieves the peak strain at a point in time.
+     *
+     * @param time The time to retrieve the peak strain at.
+     * @param current The current hit object.
+     * @returns The peak strain.
+     */
+    protected abstract calculateInitialStrain(time: number, current: DifficultyHitObject): number;
+    /**
+     * Sets the initial strain level for a new section.
+     *
+     * @param time The beginning of the new section in milliseconds.
+     * @param current The current hitobject.
+     */
+    private startNewSectionFrom;
+}
+
+/**
+ * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
+ * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
+ */
+declare abstract class DroidSkill extends StrainSkill {
+    /**
+     * The bonus multiplier that is given for a sequence of notes of equal difficulty.
+     */
+    protected abstract readonly starsPerDouble: number;
+    process(current: DifficultyHitObject): void;
+    difficultyValue(): number;
+    /**
+     * Gets the strain of a hitobject.
      *
-     * @param rating The difficulty rating.
+     * @param current The hitobject to get the strain from.
+     * @returns The strain of the hitobject.
      */
-    protected basePerformanceValue(rating: number): number;
+    protected abstract getObjectStrain(current: DifficultyHitObject): number;
+    protected calculateCurrentSectionStart(current: DifficultyHitObject): number;
 }
 
 /**
- * A converter used to convert normal hitobjects into difficulty hitobjects.
+ * Represents an osu!droid hit object with difficulty calculation values.
  */
-declare class DifficultyHitObjectCreator {
+declare class DroidDifficultyHitObject extends DifficultyHitObject {
     /**
-     * The threshold for small circle buff for osu!droid.
+     * The tap strain generated by the hitobject.
      */
-    private readonly DROID_CIRCLESIZE_BUFF_THRESHOLD;
+    tapStrain: number;
     /**
-     * The threshold for small circle buff for osu!standard.
+     * The tap strain generated by the hitobject if `strainTime` isn't modified by
+     * OD. This is used in three-finger detection.
      */
-    private readonly PC_CIRCLESIZE_BUFF_THRESHOLD;
+    originalTapStrain: number;
     /**
-     * The gamemode this creator is creating for.
+     * The rhythm strain generated by the hitobject.
      */
-    private mode;
+    rhythmStrain: number;
     /**
-     * The base normalized radius of hitobjects.
+     * The flashlight strain generated by the hitobject if sliders are considered.
      */
-    private readonly normalizedRadius;
-    private maximumSliderRadius;
-    private readonly assumedSliderRadius;
-    private readonly minDeltaTime;
+    flashlightStrainWithSliders: number;
     /**
-     * Generates difficulty hitobjects for difficulty calculation.
+     * The flashlight strain generated by the hitobject if sliders are not considered.
      */
-    generateDifficultyObjects(params: {
-        objects: readonly HitObject[];
-        circleSize: number;
-        mods: Mod[];
-        speedMultiplier: number;
-        mode: Modes;
-        preempt?: number;
-    }): DifficultyHitObject[];
+    flashlightStrainWithoutSliders: number;
     /**
-     * Calculates a slider's cursor position.
+     * The visual strain generated by the hitobject if sliders are considered.
      */
-    private calculateSliderCursorPosition;
+    visualStrainWithSliders: number;
     /**
-     * Gets the scaling factor of a radius.
-     *
-     * @param radius The radius to get the scaling factor from.
+     * The visual strain generated by the hitobject if sliders are not considered.
      */
-    private getScalingFactor;
+    visualStrainWithoutSliders: number;
     /**
-     * Returns the end cursor position of a hitobject.
+     * The note density of the hitobject.
      */
-    private getEndCursorPosition;
-    private applyToOverlappingFactor;
-}
-
-/**
- * Represents a slider that is considered difficult.
- *
- * This structure is a part of difficulty attributes and can be cached.
- */
-interface DifficultSlider {
+    noteDensity: number;
     /**
-     * The index of the slider in the beatmap.
+     * The overlapping factor of the hitobject.
+     *
+     * This is used to scale visual skill.
      */
-    readonly index: number;
+    overlappingFactor: number;
     /**
-     * The difficulty rating of this slider compared to other sliders, based on the velocity of the slider.
-     *
-     * A value closer to 1 indicates that this slider is more difficult compared to most sliders.
+     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
+     */
+    readonly timePreempt: number;
+    private readonly radiusBuffThreshold;
+    protected readonly mode = Modes.droid;
+    protected readonly maximumSliderRadius: number;
+    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).
      *
-     * A value closer to 0 indicates that this slider is easier compared to most sliders.
+     * @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.
      */
-    readonly difficultyRating: number;
-}
-
-/**
- * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
- * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
- */
-declare abstract class DroidSkill extends StrainSkill {
+    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number);
+    computeProperties(clockRate: number, hitObjects: readonly PlaceableHitObject[]): void;
     /**
-     * The bonus multiplier that is given for a sequence of notes of equal difficulty.
+     * Determines whether this hitobject is considered overlapping with the hitobject before it.
+     *
+     * 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.
      */
-    protected abstract readonly starsPerDouble: number;
-    difficultyValue(): number;
+    isOverlapping(considerDistance: boolean): boolean;
+    private setVisuals;
+    private applyToOverlappingFactor;
 }
 
 /**
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 declare class DroidAim extends DroidSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly starsPerDouble: number;
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly starsPerDouble = 1.05;
+    private readonly skillMultiplier;
     private readonly withSliders;
+    private currentAimStrain;
     constructor(mods: Mod[], withSliders: boolean);
-    /**
-     * @param current The hitobject to calculate.
-     */
-    protected strainValueAt(current: DifficultyHitObject): number;
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected getObjectStrain(): number;
     /**
      * @param current The hitobject to save to.
      */
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
 /**
  * An evaluator for calculating osu!droid Aim skill.
  */
 declare abstract class DroidAimEvaluator extends AimEvaluator {
-    protected static readonly wideAngleMultiplier: number;
-    protected static readonly sliderMultiplier: number;
-    protected static readonly velocityChangeMultiplier: number;
-    /**
-     * Spacing threshold for a single hitobject spacing.
-     */
-    private static readonly SINGLE_SPACING_THRESHOLD;
+    protected static readonly wideAngleMultiplier = 1.65;
+    protected static readonly sliderMultiplier = 1.5;
+    protected static readonly velocityChangeMultiplier = 0.85;
+    private static readonly singleSpacingThreshold;
     private static readonly minSpeedBonus;
     /**
      * Evaluates the difficulty of aiming the current object, based on:
@@ -641,15 +677,15 @@ declare abstract class DroidAimEvaluator extends AimEvaluator {
      * @param current The current object.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, withSliders: boolean): number;
     /**
-     * Calculates the aim strain of a hitobject.
+     * Calculates the snap aim strain of a hitobject.
      */
-    private static aimStrainOf;
+    private static snapAimStrainOf;
     /**
-     * Calculates the movement strain of a hitobject.
+     * Calculates the flow aim strain of a hitobject.
      */
-    private static movementStrainOf;
+    private static flowAimStrainOf;
 }
 
 /**
@@ -668,6 +704,40 @@ interface DroidDifficultyAttributes extends DifficultyAttributes {
      * The difficulty corresponding to the visual skill.
      */
     visualDifficulty: number;
+    /**
+     * The amount of strains that are considered difficult with respect to the tap skill.
+     */
+    tapDifficultStrainCount: number;
+    /**
+     * The amount of strains that are considered difficult with respect to the flashlight skill.
+     */
+    flashlightDifficultStrainCount: number;
+    /**
+     * The amount of strains that are considered difficult with respect to the visual skill.
+     */
+    visualDifficultStrainCount: number;
+    /**
+     * The average delta time of speed objects.
+     */
+    averageSpeedDeltaTime: number;
+    /**
+     * Describes how much of tap difficulty is contributed by notes that are "vibroable".
+     *
+     * A value closer to 1 indicates most of tap difficulty is contributed by notes that are not "vibroable".
+     *
+     * A value closer to 0 indicates most of tap difficulty is contributed by notes that are "vibroable".
+     */
+    vibroFactor: number;
+}
+
+/**
+ * Represents options for osu!droid difficulty calculation.
+ */
+interface DroidDifficultyCalculationOptions extends DifficultyCalculationOptions {
+    /**
+     * Whether to calculate for old statistics (1.6.7 and older). Defaults to `false`.
+     */
+    readonly oldStatistics?: boolean;
 }
 
 /**
@@ -693,6 +763,10 @@ interface HighStrainSection {
  * as doing some analysis using the replay of a score.
  */
 interface ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes {
+    /**
+     * The mode of the difficulty calculation.
+     */
+    mode: "live";
     /**
      * Possible sections at which the player can use three fingers on.
      */
@@ -728,36 +802,38 @@ interface ExtendedDroidDifficultyAttributes extends DroidDifficultyAttributes {
 /**
  * A difficulty calculator for osu!droid gamemode.
  */
-declare class DroidDifficultyCalculator extends DifficultyCalculator {
+declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidDifficultyHitObject, DroidDifficultyAttributes> {
     /**
      * The aim star rating of the beatmap.
      */
-    aim: number;
+    get aim(): number;
     /**
      * The tap star rating of the beatmap.
      */
-    tap: number;
+    get tap(): number;
     /**
      * The rhythm star rating of the beatmap.
      */
-    rhythm: number;
+    get rhythm(): number;
     /**
      * The flashlight star rating of the beatmap.
      */
-    flashlight: number;
+    get flashlight(): number;
     /**
      * The visual star rating of the beatmap.
      */
-    visual: number;
+    get visual(): number;
     /**
      * The strain threshold to start detecting for possible three-fingered section.
      *
      * Increasing this number will result in less sections being flagged.
      */
-    static readonly threeFingerStrainThreshold: number;
+    static readonly threeFingerStrainThreshold = 175;
     readonly attributes: ExtendedDroidDifficultyAttributes;
-    protected readonly difficultyMultiplier: number;
-    protected readonly mode: Modes;
+    get cacheableAttributes(): CacheableDifficultyAttributes<DroidDifficultyAttributes>;
+    protected readonly difficultyMultiplier = 0.18;
+    protected readonly mode = Modes.droid;
+    calculate(options?: DroidDifficultyCalculationOptions): this;
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
@@ -781,8 +857,9 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator {
     calculateTotal(): void;
     calculateAll(): void;
     toString(): string;
-    protected preProcess(): void;
+    protected generateDifficultyHitObjects(beatmap: Beatmap, clockRate: number): DroidDifficultyHitObject[];
     protected createSkills(): DroidSkill[];
+    protected calculateClockRate(options?: DroidDifficultyCalculationOptions): number;
     /**
      * Called after aim skill calculation.
      *
@@ -797,21 +874,14 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator {
     /**
      * Called after tap skill calculation.
      *
-     * @param tapSkill The tap skill.
+     * @param tapSkillCheese The tap skill that considers cheesing.
+     * @param tapSkillVibro The tap skill that considers vibro.
      */
     private postCalculateTap;
     /**
-     * Calculates speed-related attributes.
-     */
-    private calculateSpeedAttributes;
-    /**
-     * Calculates the sum of strains for possible three-fingered sections.
-     *
-     * @param firstObjectIndex The index of the first object in the section.
-     * @param lastObjectIndex The index of the last object in the section.
-     * @returns The summed strain of the section.
+     * Calculates tap-related attributes.
      */
-    private calculateThreeFingerSummedStrain;
+    private calculateTapAttributes;
     /**
      * Called after rhythm skill calculation.
      *
@@ -838,19 +908,20 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator {
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 declare class DroidFlashlight extends DroidSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly starsPerDouble: number;
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 0;
+    protected readonly reducedSectionBaseline = 1;
+    protected readonly starsPerDouble = 1.06;
+    private readonly skillMultiplier;
     private readonly isHidden;
     private readonly withSliders;
+    private currentFlashlightStrain;
     constructor(mods: Mod[], withSliders: boolean);
-    /**
-     * @param current The hitobject to calculate.
-     */
-    protected strainValueAt(current: DifficultyHitObject): number;
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
+    protected getObjectStrain(): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
+    difficultyValue(): number;
 }
 
 /**
@@ -883,7 +954,7 @@ declare abstract class DroidFlashlightEvaluator extends FlashlightEvaluator {
      * @param isHiddenMod Whether the Hidden mod is enabled.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, isHiddenMod: boolean, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, isHiddenMod: boolean, withSliders: boolean): number;
 }
 
 /**
@@ -923,7 +994,7 @@ interface PerformanceCalculationOptions {
 /**
  * The base class of performance calculators.
  */
-declare abstract class PerformanceCalculator {
+declare abstract class PerformanceCalculator<T extends DifficultyAttributes> {
     /**
      * The overall performance value.
      */
@@ -935,11 +1006,7 @@ declare abstract class PerformanceCalculator {
     /**
      * The difficulty attributes that is being calculated.
      */
-    abstract readonly difficultyAttributes: DifficultyAttributes;
-    /**
-     * Penalty for combo breaks.
-     */
-    protected comboPenalty: number;
+    readonly difficultyAttributes: T;
     /**
      * The global multiplier to be applied to the final performance value.
      *
@@ -958,6 +1025,10 @@ declare abstract class PerformanceCalculator {
      * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
      */
     protected sliderNerfFactor: number;
+    /**
+     * @param difficultyAttributes The difficulty attributes to calculate.
+     */
+    constructor(difficultyAttributes: T | CacheableDifficultyAttributes<T>);
     /**
      * Calculates the performance points of the beatmap.
      *
@@ -977,7 +1048,7 @@ declare abstract class PerformanceCalculator {
     /**
      * Calculates the total performance value of the beatmap and stores it in this instance.
      */
-    protected abstract calculateTotalValue(): void;
+    protected abstract calculateTotalValue(): number;
     /**
      * The total hits that can be done in the beatmap.
      */
@@ -996,16 +1067,31 @@ declare abstract class PerformanceCalculator {
      * @param options Options for performance calculation.
      */
     protected handleOptions(options?: PerformanceCalculationOptions): void;
+    /**
+     * Calculates a strain-based miss penalty.
+     *
+     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
+     * so we use the amount of relatively difficult sections to adjust miss penalty
+     * to make it more punishing on maps with lower amount of hard sections.
+     */
+    protected calculateStrainBasedMissPenalty(difficultStrainCount: number): number;
     /**
      * Calculates the amount of misses + sliderbreaks from combo.
      */
     private calculateEffectiveMissCount;
+    /**
+     * Determines whether an attribute is a cacheable attribute.
+     *
+     * @param attributes The attributes to check.
+     * @returns Whether the attributes are cacheable.
+     */
+    private isCacheableAttribute;
 }
 
 /**
  * A performance points calculator that calculates performance points for osu!droid gamemode.
  */
-declare class DroidPerformanceCalculator extends PerformanceCalculator {
+declare class DroidPerformanceCalculator extends PerformanceCalculator<DroidDifficultyAttributes> {
     /**
      * The aim performance value.
      */
@@ -1058,19 +1144,14 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      * Can be properly obtained by analyzing the replay associated with the score.
      */
     get visualSliderCheesePenalty(): number;
-    readonly difficultyAttributes: DroidDifficultyAttributes;
     protected finalMultiplier: number;
-    protected readonly mode: Modes;
+    protected readonly mode = Modes.droid;
     private _aimSliderCheesePenalty;
     private _flashlightSliderCheesePenalty;
     private _visualSliderCheesePenalty;
     private _tapPenalty;
     private _deviation;
     private _tapDeviation;
-    /**
-     * @param difficultyAttributes The difficulty attributes to calculate.
-     */
-    constructor(difficultyAttributes: DroidDifficultyAttributes);
     /**
      * Applies a tap penalty value to this calculator.
      *
@@ -1104,7 +1185,7 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      */
     applyVisualSliderCheesePenalty(value: number): void;
     protected calculateValues(): void;
-    protected calculateTotalValue(): void;
+    protected calculateTotalValue(): number;
     protected handleOptions(options?: PerformanceCalculationOptions): void;
     /**
      * Calculates the aim performance value of the beatmap.
@@ -1126,6 +1207,19 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      * Calculates the visual performance value of the beatmap.
      */
     private calculateVisualValue;
+    /**
+     * The object-based proportional miss penalty.
+     */
+    private get proportionalMissPenalty();
+    /**
+     * Calculates the object-based length scaling based on the deviation of a player for a full
+     * combo in this beatmap, taking retries into account.
+     *
+     * @param objectCount The amount of objects to be considered. Defaults to the amount of
+     * objects in this beatmap.
+     * @param punishForMemorization Whether to punish the deviation for memorization. Defaults to `false`.
+     */
+    private calculateDeviationBasedLengthScaling;
     /**
      * Estimates the player's tap deviation based on the OD, number of circles and sliders,
      * and number of 300s, 100s, 50s, and misses, assuming the player's mean hit error is 0.
@@ -1148,6 +1242,7 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      * This is fine though, since this method is only used to scale tap pp.
      */
     private calculateTapDeviation;
+    private getConvertedHitWindow;
     toString(): string;
 }
 
@@ -1155,63 +1250,69 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
  * Represents the skill required to properly follow a beatmap's rhythm.
  */
 declare class DroidRhythm extends DroidSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly strainDecayBase: number;
-    protected readonly starsPerDouble: number;
-    private currentRhythm;
-    private readonly hitWindow;
-    constructor(mods: Mod[], overallDifficulty: number);
-    protected strainValueAt(current: DifficultyHitObject): number;
-    protected saveToHitObject(current: DifficultyHitObject): 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;
+    protected readonly reducedSectionCount = 5;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly strainDecayBase = 0.3;
+    protected readonly starsPerDouble = 1.75;
+    private currentRhythmStrain;
+    private currentRhythmMultiplier;
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected getObjectStrain(): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
 /**
  * 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: DifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject): number;
 }
 
 /**
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
 declare class DroidTap extends DroidSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly strainDecayBase: number;
-    protected readonly starsPerDouble: number;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly strainDecayBase = 0.3;
+    protected readonly starsPerDouble = 1.1;
     private currentTapStrain;
-    private currentOriginalTapStrain;
-    private readonly greatWindow;
-    constructor(mods: Mod[], overallDifficulty: number);
+    private currentRhythmMultiplier;
+    private readonly skillMultiplier;
+    private readonly considerCheesability;
+    private readonly strainTimeCap?;
+    private readonly _objectDeltaTimes;
     /**
-     * @param current The hitobject to calculate.
+     * The delta time of hitobjects.
+     */
+    get objectDeltaTimes(): readonly number[];
+    constructor(mods: Mod[], considerCheesability: boolean, strainTimeCap?: number);
+    /**
+     * The amount of notes that are relevant to the difficulty.
+     */
+    relevantNoteCount(): number;
+    /**
+     * The delta time relevant to the difficulty.
      */
-    protected strainValueAt(current: DifficultyHitObject): number;
+    relevantDeltaTime(): number;
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected getObjectStrain(): number;
     /**
      * @param current The hitobject to save to.
      */
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
 /**
@@ -1232,33 +1333,39 @@ declare abstract class DroidTapEvaluator extends SpeedEvaluator {
      *
      * - time between pressing the previous and current object,
      * - distance between those objects,
-     * - and how easily they can be cheesed.
+     * - how easily they can be cheesed,
+     * - and the strain time cap.
      *
      * @param current The current object.
      * @param greatWindow The great hit window of the current object.
      * @param considerCheesability Whether to consider cheesability.
+     * @param strainTimeCap The strain time to cap the object's strain time to.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, greatWindow: number, considerCheesability: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, considerCheesability: boolean, strainTimeCap?: number): number;
 }
 
 /**
  * Represents the skill required to read every object in the map.
  */
 declare class DroidVisual extends DroidSkill {
-    protected readonly starsPerDouble: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
+    protected readonly starsPerDouble = 1.025;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly strainDecayBase = 0.1;
     private readonly isHidden;
     private readonly withSliders;
+    private currentVisualStrain;
+    private currentRhythmMultiplier;
+    private readonly skillMultiplier;
     constructor(mods: Mod[], withSliders: boolean);
-    protected strainValueAt(current: DifficultyHitObject): number;
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected getObjectStrain(): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
 /**
- * An evaluator for calculating osu!droid Visual skill.
+ * An evaluator for calculating osu!droid visual skill.
  */
 declare abstract class DroidVisualEvaluator {
     /**
@@ -1276,7 +1383,7 @@ declare abstract class DroidVisualEvaluator {
      * @param isHiddenMod Whether the Hidden mod is enabled.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, isHiddenMod: boolean, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, isHiddenMod: boolean, withSliders: boolean): number;
 }
 
 /**
@@ -1285,51 +1392,107 @@ declare abstract class DroidVisualEvaluator {
  */
 declare abstract class OsuSkill extends StrainSkill {
     /**
-     * The default multiplier applied to the final difficulty value after all other calculations.
-     *
-     * May be overridden via {@link difficultyMultiplier}.
+     * The weight by which each strain value decays.
      */
-    static readonly defaultDifficultyMultiplier: number;
+    protected abstract readonly decayWeight: number;
+    difficultyValue(): number;
+}
+
+/**
+ * Represents an osu!standard hit object with difficulty calculation values.
+ */
+declare class OsuDifficultyHitObject extends DifficultyHitObject {
     /**
-     * The final multiplier to be applied to the final difficulty value after all other calculations.
+     * The speed strain generated by the hitobject.
      */
-    protected readonly difficultyMultiplier: number;
+    speedStrain: number;
     /**
-     * The weight by which each strain value decays.
+     * The flashlight strain generated by this hitobject.
      */
-    protected abstract readonly decayWeight: number;
-    difficultyValue(): number;
+    flashlightStrain: number;
+    private readonly radiusBuffThreshold;
+    protected readonly mode = Modes.osu;
+    protected get scalingFactor(): number;
+}
+
+/**
+ * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
+ */
+declare class OsuAim extends OsuSkill {
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly decayWeight = 0.9;
+    private currentAimStrain;
+    private readonly skillMultiplier;
+    private readonly withSliders;
+    constructor(mods: Mod[], withSliders: boolean);
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
+    /**
+     * @param current The hitobject to save to.
+     */
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
+}
+
+/**
+ * An evaluator for calculating osu!standard Aim skill.
+ */
+declare abstract class OsuAimEvaluator extends AimEvaluator {
+    /**
+     * Evaluates the difficulty of aiming the current object, based on:
+     *
+     * - cursor velocity to the current object,
+     * - angle difficulty,
+     * - sharp velocity increases,
+     * - and slider difficulty.
+     *
+     * @param current The current object.
+     * @param withSliders Whether to take slider difficulty into account.
+     */
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, withSliders: boolean): number;
 }
 
 /**
  * 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.
      */
     speedDifficulty: number;
+    /**
+     * The amount of strains that are considered difficult with respect to the speed skill.
+     */
+    speedDifficultStrainCount: number;
 }
 
 /**
  * A difficulty calculator for osu!standard gamemode.
  */
-declare class OsuDifficultyCalculator extends DifficultyCalculator {
+declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuDifficultyHitObject, OsuDifficultyAttributes> {
     /**
      * The aim star rating of the beatmap.
      */
-    aim: number;
+    get aim(): number;
     /**
      * The speed star rating of the beatmap.
      */
-    speed: number;
+    get speed(): number;
     /**
      * The flashlight star rating of the beatmap.
      */
-    flashlight: number;
+    get flashlight(): number;
     readonly attributes: OsuDifficultyAttributes;
-    protected readonly difficultyMultiplier: number;
-    protected readonly mode: Modes;
+    get cacheableAttributes(): CacheableDifficultyAttributes<OsuDifficultyAttributes>;
+    protected readonly difficultyMultiplier = 0.0675;
+    protected readonly mode = Modes.osu;
     /**
      * Calculates the aim star rating of the beatmap and stores it in this instance.
      */
@@ -1345,8 +1508,9 @@ declare class OsuDifficultyCalculator extends DifficultyCalculator {
     calculateTotal(): void;
     calculateAll(): void;
     toString(): string;
-    protected preProcess(): void;
+    protected generateDifficultyHitObjects(beatmap: Beatmap, clockRate: number): OsuDifficultyHitObject[];
     protected createSkills(): OsuSkill[];
+    protected populateDifficultyAttributes(beatmap: Beatmap, clockRate: number): void;
     /**
      * Called after aim skill calculation.
      *
@@ -1372,87 +1536,22 @@ declare class OsuDifficultyCalculator extends DifficultyCalculator {
     private postCalculateFlashlight;
 }
 
-/**
- * A difficulty calculator that calculates for both osu!droid and osu!standard gamemode.
- */
-declare class MapStars {
-    /**
-     * The osu!droid difficulty calculator of the beatmap.
-     */
-    readonly droid: DroidDifficultyCalculator;
-    /**
-     * The osu!standard difficulty calculator of the beatmap.
-     */
-    readonly osu: OsuDifficultyCalculator;
-    /**
-     * Constructs this instance and calculates the given beatmap's osu!droid and osu!standard difficulty.
-     *
-     * @param beatmap The beatmap to calculate.
-     * @param options Options for the difficulty calculation.
-     */
-    constructor(beatmap: Beatmap, options?: DifficultyCalculationOptions);
-    /**
-     * Returns a string representative of the class.
-     */
-    toString(): string;
-}
-
-/**
- * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
- */
-declare class OsuAim extends OsuSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly difficultyMultiplier: number;
-    protected readonly decayWeight: number;
-    private readonly withSliders;
-    constructor(mods: Mod[], withSliders: boolean);
-    /**
-     * @param current The hitobject to calculate.
-     */
-    protected strainValueAt(current: DifficultyHitObject): number;
-    /**
-     * @param current The hitobject to save to.
-     */
-    protected saveToHitObject(current: DifficultyHitObject): void;
-}
-
-/**
- * An evaluator for calculating osu!standard Aim skill.
- */
-declare abstract class OsuAimEvaluator extends AimEvaluator {
-    /**
-     * Evaluates the difficulty of aiming the current object, based on:
-     *
-     * - cursor velocity to the current object,
-     * - angle difficulty,
-     * - sharp velocity increases,
-     * - and slider difficulty.
-     *
-     * @param current The current object.
-     * @param withSliders Whether to take slider difficulty into account.
-     */
-    static evaluateDifficultyOf(current: DifficultyHitObject, withSliders: boolean): number;
-}
-
 /**
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 declare class OsuFlashlight extends OsuSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly decayWeight: number;
+    protected readonly strainDecayBase = 0.15;
+    protected readonly reducedSectionCount = 0;
+    protected readonly reducedSectionBaseline = 1;
+    protected readonly decayWeight = 1;
+    private currentFlashlightStrain;
+    private readonly skillMultiplier;
     private readonly isHidden;
     constructor(mods: Mod[]);
-    /**
-     * @param current The hitobject to calculate.
-     */
-    protected strainValueAt(current: DifficultyHitObject): number;
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    difficultyValue(): number;
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
 }
 
 /**
@@ -1471,13 +1570,13 @@ declare abstract class OsuFlashlightEvaluator extends FlashlightEvaluator {
      * @param current The current object.
      * @param isHiddenMod Whether the Hidden mod is enabled.
      */
-    static evaluateDifficultyOf(current: DifficultyHitObject, isHiddenMod: boolean): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, isHiddenMod: boolean): number;
 }
 
 /**
  * A performance points calculator that calculates performance points for osu!standard gamemode.
  */
-declare class OsuPerformanceCalculator extends PerformanceCalculator {
+declare class OsuPerformanceCalculator extends PerformanceCalculator<OsuDifficultyAttributes> {
     /**
      * The aim performance value.
      */
@@ -1494,15 +1593,12 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator {
      * The flashlight performance value.
      */
     flashlight: number;
-    readonly difficultyAttributes: OsuDifficultyAttributes;
     protected finalMultiplier: number;
-    protected readonly mode: Modes;
-    /**
-     * @param difficultyAttributes The difficulty attributes to calculate.
-     */
-    constructor(difficultyAttributes: OsuDifficultyAttributes);
+    protected readonly mode = Modes.osu;
+    private comboPenalty;
     protected calculateValues(): void;
-    protected calculateTotalValue(): void;
+    protected calculateTotalValue(): number;
+    protected handleOptions(options?: PerformanceCalculationOptions): void;
     /**
      * Calculates the aim performance value of the beatmap.
      */
@@ -1525,39 +1621,40 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator {
 /**
  * An evaluator for calculating osu!standard Rhythm skill.
  */
-declare abstract class OsuRhythmEvaluator extends RhythmEvaluator {
+declare abstract class OsuRhythmEvaluator {
+    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: DifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
 }
 
 /**
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
 declare class OsuSpeed extends OsuSkill {
-    protected readonly skillMultiplier: number;
-    protected readonly strainDecayBase: number;
-    protected readonly reducedSectionCount: number;
-    protected readonly reducedSectionBaseline: number;
-    protected readonly difficultyMultiplier: number;
-    protected readonly decayWeight: number;
+    protected readonly strainDecayBase = 0.3;
+    protected readonly reducedSectionCount = 5;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly decayWeight = 0.9;
     private currentSpeedStrain;
     private currentRhythm;
-    private readonly greatWindow;
-    constructor(mods: Mod[], greatWindow: number);
+    private readonly skillMultiplier;
     /**
      * @param current The hitobject to calculate.
      */
-    protected strainValueAt(current: DifficultyHitObject): number;
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
     /**
      * @param current The hitobject to save to.
      */
-    protected saveToHitObject(current: DifficultyHitObject): void;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
 }
 
 /**
@@ -1566,8 +1663,11 @@ declare class OsuSpeed extends OsuSkill {
 declare abstract class OsuSpeedEvaluator extends SpeedEvaluator {
     /**
      * Spacing threshold for a single hitobject spacing.
+     *
+     * About 1.25 circles distance between hitobject centers.
      */
     private static readonly SINGLE_SPACING_THRESHOLD;
+    private static readonly DISTANCE_MULTIPLIER;
     /**
      * Evaluates the difficulty of tapping the current object, based on:
      *
@@ -1576,9 +1676,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: DifficultyHitObject, greatWindow: number): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
 }
 
-export { AimEvaluator, CalculationOptions, DifficultSlider, DifficultyAttributes, DifficultyCalculationOptions, DifficultyCalculator, DifficultyHitObject, DifficultyHitObjectCreator, DroidAim, DroidAimEvaluator, DroidDifficultyAttributes, DroidDifficultyCalculator, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, ExtendedDroidDifficultyAttributes, FlashlightEvaluator, HighStrainSection, MapStars, OsuAim, OsuAimEvaluator, OsuDifficultyAttributes, OsuDifficultyCalculator, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, PerformanceCalculationOptions, PerformanceCalculator, RhythmEvaluator, SpeedEvaluator, 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 };