@rian8337/osu-difficulty-calculator 4.0.0-beta.90 → 4.0.0-beta.91

package/typings/index.d.ts

@@ -1,115 +1,4 @@
-import { ModMap, SerializedMod, PlaceableHitObject, Vector2, Modes, PlayableBeatmap, Mod, Beatmap, DroidPlayableBeatmap, Accuracy, OsuPlayableBeatmap } from '@rian8337/osu-base';
-
-/**
- * Holds data that can be used to calculate performance points.
- */
-interface IDifficultyAttributes {
-    /**
-     * The mods which were applied to the beatmap.
-     */
-    mods: ModMap;
-    /**
-     * The combined star rating of all skills.
-     */
-    starRating: number;
-    /**
-     * The maximum achievable combo.
-     */
-    maxCombo: number;
-    /**
-     * The difficulty corresponding to the aim skill.
-     */
-    aimDifficulty: number;
-    /**
-     * The difficulty corresponding to the flashlight skill.
-     */
-    flashlightDifficulty: number;
-    /**
-     * The number of clickable objects weighted by difficulty.
-     *
-     * Related to speed/tap difficulty.
-     */
-    speedNoteCount: number;
-    /**
-     * Describes how much of aim difficulty is contributed to by hitcircles or sliders.
-     *
-     * A value closer to 1 indicates most of aim difficulty is contributed by hitcircles.
-     *
-     * A value closer to 0 indicates most of aim difficulty is contributed by sliders.
-     */
-    sliderFactor: number;
-    /**
-     * The overall clock rate that was applied to the beatmap.
-     */
-    clockRate: number;
-    /**
-     * The perceived overall difficulty **exclusive** of rate-adjusting mods (DT/HT/etc).
-     *
-     * Rate-adjusting mods don't directly affect the overall difficulty value, but have a perceived effect as a result of adjusting audio timing.
-     */
-    overallDifficulty: number;
-    /**
-     * The number of hitcircles in the beatmap.
-     */
-    hitCircleCount: number;
-    /**
-     * The number of sliders in the beatmap.
-     */
-    sliderCount: number;
-    /**
-     * The number of spinners in the beatmap.
-     */
-    spinnerCount: number;
-    /**
-     * The number of sliders weighted by difficulty.
-     */
-    aimDifficultSliderCount: 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 IDifficultyAttributes> = Omit<T, "mods" | "toCacheableAttributes"> & {
-    /**
-     * The mods which were applied to the beatmap.
-     */
-    mods: SerializedMod[];
-};
-
-/**
- * Holds data that can be used to calculate performance points.
- */
-declare abstract class DifficultyAttributes implements IDifficultyAttributes {
-    mods: ModMap;
-    starRating: number;
-    maxCombo: number;
-    aimDifficulty: number;
-    flashlightDifficulty: number;
-    speedNoteCount: number;
-    sliderFactor: number;
-    clockRate: number;
-    overallDifficulty: number;
-    hitCircleCount: number;
-    sliderCount: number;
-    spinnerCount: number;
-    aimDifficultSliderCount: number;
-    aimDifficultStrainCount: number;
-    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IDifficultyAttributes>);
-    /**
-     * Converts this `DifficultyAttributes` instance to an attribute structure that can be cached.
-     *
-     * @returns The cacheable attributes.
-     */
-    toCacheableAttributes(): CacheableDifficultyAttributes<this>;
-    /**
-     * Returns a string representation of the difficulty attributes.
-     */
-    toString(): string;
-}
+import { PlaceableHitObject, Vector2, Modes, ModMap, HitResult, HitWindow, SerializedMod, PlayableBeatmap, Mod, Beatmap, Accuracy, DroidPlayableBeatmap, OsuPlayableBeatmap } from '@rian8337/osu-base';
 
 /**
  * Represents a hit object with difficulty calculation values.
@@ -133,10 +22,18 @@ declare abstract class DifficultyHitObject {
      * The aim strain generated by the hitobject if sliders are not considered.
      */
     aimStrainWithoutSliders: number;
+    /**
+     * The flashlight strain generated by the hitobject.
+     */
+    flashlightStrain: number;
     /**
      * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
      */
     rhythmMultiplier: number;
+    /**
+     * The normalized distance from the start position of the previous hitobject to the start position of this hitobject.
+     */
+    jumpDistance: number;
     /**
      * The normalized distance from the "lazy" end position of the previous hitobject to the start position of this hitobject.
      *
@@ -188,7 +85,18 @@ declare abstract class DifficultyHitObject {
      *
      * Calculated as the angle between the circles (current-2, current-1, current).
      */
-    angle: number | null;
+    angleSigned: number | null;
+    /**
+     * Unsigned angle the player has to take to hit this hitobject.
+     *
+     * Calculated as the angle between the circles (current-2, current-1, current).
+     */
+    get angle(): number | null;
+    /**
+     * Angle of the vector created between current and current-1 normalized to consider
+     * symmetrical vectors in any axis to be the same angle.
+     */
+    normalizedVectorAngle: number | null;
     /**
      * The amount of milliseconds elapsed between this hitobject and the last hitobject.
      */
@@ -197,6 +105,11 @@ declare abstract class DifficultyHitObject {
      * The amount of milliseconds elapsed since the start time of the previous hitobject, with a minimum of 25ms.
      */
     readonly strainTime: number;
+    /**
+     * The amount of milliseconds elapsed between the last {@link DifficultyHitObject}'s {@link endTime} and
+     * this {@link DifficultyHitObject}'s {@link startTime} capped to a minimum of {@link minDeltaTime}ms.
+     */
+    readonly lastObjectEndDeltaTime: number;
     /**
      * Adjusted start time of the hitobject, taking speed multiplier into account.
      */
@@ -206,13 +119,21 @@ declare abstract class DifficultyHitObject {
      */
     readonly endTime: number;
     /**
-     * The full great window of the hitobject.
+     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
+     */
+    readonly timePreempt: number;
+    /**
+     * The beatmap clock rate.
      */
-    readonly fullGreatWindow: number;
+    readonly clockRate: number;
     /**
      * Selective bonus for beatmaps with higher circle size.
      */
     abstract get smallCircleBonus(): number;
+    /**
+     * This {@link DifficultyHitObject}'s immediate overall difficulty value calculated from the raw hitwindow.
+     */
+    get overallDifficulty(): number;
     /**
      * Other hitobjects in the beatmap, including this hitobject.
      */
@@ -220,14 +141,14 @@ declare abstract class DifficultyHitObject {
     /**
      * The normalized radius of the hitobject.
      */
-    static readonly normalizedRadius: number;
+    abstract readonly normalizedRadius: number;
     /**
      * The normalized diameter of the hitobject.
      */
-    static get normalizedDiameter(): number;
+    get normalizedDiameter(): number;
     protected abstract readonly mode: Modes;
-    protected readonly maximumSliderRadius: number;
-    protected readonly assumedSliderRadius: number;
+    protected get maximumSliderRadius(): number;
+    protected get assumedSliderRadius(): number;
     /**
      * The lowest possible delta time value.
      */
@@ -278,10 +199,10 @@ declare abstract class DifficultyHitObject {
      * Calculates the opacity of the hitobject at a given time.
      *
      * @param time The time to calculate the hitobject's opacity at.
-     * @param mods The mods used.
+     * @param mods The mods used. Defaults to No Mod.
      * @returns The opacity of the hitobject at the given time.
      */
-    opacityAt(time: number, mods: ModMap): number;
+    opacityAt(time: number, mods?: ModMap): number;
     /**
      * How possible is it to doubletap this object together with the next one and get perfect
      * judgement in range from 0 to 1.
@@ -289,154 +210,210 @@ declare abstract class DifficultyHitObject {
      * A value closer to 1 indicates a higher possibility.
      */
     getDoubletapness(nextObj: this | null): number;
-    protected setDistances(clockRate: number): void;
-    private calculateSliderCursorPosition;
-    private getEndCursorPosition;
-}
-
-/**
- * A bare minimal abstract skill for fully custom skill implementations.
- *
- * This class should be considered a "processing" class and not persisted.
- */
-declare abstract class Skill {
-    /**
-     * The mods that this skill processes.
-     */
-    protected readonly mods: ModMap;
-    constructor(mods: ModMap);
     /**
-     * Processes a hitobject.
-     *
-     * @param current The hitobject to process.
+     * Retrieves the full rate-adjusted hit window for a {@link HitResult}.
      */
-    abstract process(current: DifficultyHitObject): void;
+    hitWindowFor(result: HitResult): number;
     /**
-     * Returns the calculated difficulty value representing all hitobjects that have been processed up to this point.
+     * The {@link HitWindow} for this {@link DifficultyHitObject}.
      */
-    abstract difficultyValue(): number;
+    protected get rawHitWindow(): HitWindow;
+    private setDistances;
+    private calculateAngle;
+    private calculateSliderAngle;
+    private calculateSliderCursorPosition;
+    private getEndCursorPosition;
 }
 
 /**
- * Represents the strain peaks of various calculated difficulties.
+ * Holds data that can be used to calculate performance points.
  */
-interface StrainPeaks {
-    /**
-     * The strain peaks of aim difficulty if sliders are considered.
-     */
-    aimWithSliders: readonly number[];
-    /**
-     * The strain peaks of aim difficulty if sliders are not considered.
-     */
-    aimWithoutSliders: readonly number[];
+interface IDifficultyAttributes {
     /**
-     * The strain peaks of speed difficulty.
+     * The mods which were applied to the beatmap.
      */
-    speed: readonly number[];
+    mods: ModMap;
     /**
-     * The strain peaks of flashlight difficulty.
+     * The combined star rating of all skills.
      */
-    flashlight: readonly 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 {
+    starRating: number;
     /**
-     * Strain peaks are stored here.
+     * The maximum achievable combo.
      */
-    readonly strainPeaks: number[];
+    maxCombo: 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.
+     * The difficulty corresponding to the aim skill.
      */
-    protected abstract readonly reducedSectionCount: number;
+    aimDifficulty: number;
     /**
-     * The baseline multiplier applied to the section with the biggest strain.
+     * The difficulty corresponding to the flashlight skill.
      */
-    protected abstract readonly reducedSectionBaseline: number;
+    flashlightDifficulty: number;
     /**
-     * Determines how quickly strain decays for the given skill.
+     * The number of clickable objects weighted by difficulty.
      *
-     * 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.
+     * Related to speed/tap difficulty.
      */
-    get objectStrains(): readonly number[];
-    private readonly sectionLength;
-    private currentStrain;
-    private currentSectionPeak;
-    private currentSectionEnd;
+    speedNoteCount: number;
     /**
-     * Converts a difficulty value to a performance value.
+     * Describes how much of aim difficulty is contributed to by hitcircles or sliders.
      *
-     * @param difficulty The difficulty value to convert.
-     * @returns The performance value.
-     */
-    static difficultyToPerformance(difficulty: number): number;
-    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.
+     * A value closer to 1 indicates most of aim difficulty is contributed by hitcircles.
+     *
+     * A value closer to 0 indicates most of aim difficulty is contributed by sliders.
      */
-    saveCurrentPeak(): void;
+    sliderFactor: number;
     /**
-     * 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.
+     * The overall clock rate that was applied to the beatmap.
      */
-    countTopWeightedStrains(): number;
+    clockRate: number;
     /**
-     * Calculates strain decay for a specified time frame.
+     * The perceived overall difficulty **exclusive** of rate-adjusting mods (DT/HT/etc).
      *
-     * @param ms The time frame to calculate.
+     * Rate-adjusting mods don't directly affect the overall difficulty value, but have a perceived effect as a result of adjusting audio timing.
      */
-    protected strainDecay(ms: number): number;
+    overallDifficulty: 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.
+     * The number of hitcircles in the beatmap.
      */
-    protected calculateCurrentSectionStart(current: DifficultyHitObject): number;
+    hitCircleCount: number;
     /**
-     * Calculates the strain value at a hitobject.
-     *
-     * @param current The hitobject to calculate.
+     * The number of sliders in the beatmap.
      */
-    protected abstract strainValueAt(current: DifficultyHitObject): number;
+    sliderCount: number;
     /**
-     * Saves the current strain to a hitobject.
+     * The number of spinners in the beatmap.
      */
-    protected abstract saveToHitObject(current: DifficultyHitObject): void;
+    spinnerCount: number;
     /**
-     * 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.
+     * The number of sliders weighted by difficulty.
      */
-    protected abstract calculateInitialStrain(time: number, current: DifficultyHitObject): number;
+    aimDifficultSliderCount: 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.
+     * The amount of strains that are considered difficult with respect to the aim skill.
      */
-    private startNewSectionFrom;
+    aimDifficultStrainCount: number;
 }
 
 /**
- * The base of a difficulty calculator.
+ * Represents difficulty attributes that can be cached.
  */
-declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, THitObject extends DifficultyHitObject, TAttributes extends DifficultyAttributes> {
+type CacheableDifficultyAttributes<T extends IDifficultyAttributes> = Omit<T, "mods" | "toCacheableAttributes"> & {
     /**
-     * `Mod`s that adjust the difficulty of a beatmap.
+     * The mods which were applied to the beatmap.
+     */
+    mods: SerializedMod[];
+};
+
+/**
+ * Holds data that can be used to calculate performance points.
+ */
+declare abstract class DifficultyAttributes implements IDifficultyAttributes {
+    mods: ModMap;
+    starRating: number;
+    maxCombo: number;
+    aimDifficulty: number;
+    flashlightDifficulty: number;
+    speedNoteCount: number;
+    sliderFactor: number;
+    clockRate: number;
+    overallDifficulty: number;
+    hitCircleCount: number;
+    sliderCount: number;
+    spinnerCount: number;
+    aimDifficultSliderCount: number;
+    aimDifficultStrainCount: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IDifficultyAttributes>);
+    /**
+     * Converts this `DifficultyAttributes` instance to an attribute structure that can be cached.
+     *
+     * @returns The cacheable attributes.
+     */
+    toCacheableAttributes(): CacheableDifficultyAttributes<this>;
+    /**
+     * Returns a string representation of the difficulty attributes.
+     */
+    toString(): string;
+}
+
+/**
+ * Represents the strain peaks of various calculated difficulties.
+ */
+interface StrainPeaks {
+    /**
+     * The strain peaks of aim difficulty if sliders are considered.
+     */
+    aimWithSliders: readonly number[];
+    /**
+     * The strain peaks of aim difficulty if sliders are not considered.
+     */
+    aimWithoutSliders: readonly number[];
+    /**
+     * The strain peaks of speed difficulty.
+     */
+    speed: readonly number[];
+    /**
+     * The strain peaks of flashlight difficulty.
+     */
+    flashlight: readonly number[];
+}
+
+/**
+ * An interface for `Skill`s that have peak difficulties.
+ */
+interface IHasPeakDifficulty {
+    /**
+     * The peak difficulties calculated by this `Skill`.
+     */
+    get peaks(): readonly number[];
+}
+
+/**
+ * A bare minimal abstract skill for fully custom skill implementations.
+ */
+declare abstract class Skill {
+    /**
+     * The mods that this skill processes.
+     */
+    protected readonly mods: ModMap;
+    private _objectDifficulties;
+    /**
+     * The difficulties of {@link DifficultyHitObject}s, populated by {@link Skill.process}.
+     */
+    protected get objectDifficulties(): readonly number[];
+    constructor(mods: ModMap);
+    /**
+     * 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;
+    /**
+     * Returns the calculated difficulty value representing all hitobjects that have been processed up to this point.
+     */
+    abstract difficultyValue(): number;
+    /**
+     * Saves the calculated difficulty to a {@link DifficultyHitObject}.
+     *
+     * @param current The {@link DifficultyHitObject} to save the difficulty to.
+     * @param difficulty The difficulty to save.
+     */
+    protected saveToHitObject(current: DifficultyHitObject, difficulty: number): void;
+    /**
+     * Calculates the difficulty value of a hitobject and stores the value in it.
+     *
+     * @param current The hitobject to process.
+     */
+    protected abstract processInternal(current: DifficultyHitObject): number;
+}
+
+/**
+ * The base of a difficulty calculator.
+ */
+declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, THitObject extends DifficultyHitObject, TAttributes extends DifficultyAttributes> {
+    /**
+     * `Mod`s that adjust the difficulty of a beatmap.
      */
     protected readonly difficultyAdjustmentMods: (typeof Mod)[];
     /**
@@ -473,15 +450,16 @@ declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, TH
      * Creates the `Skill`s to calculate the difficulty of a `PlayableBeatmap`.
      *
      * @param beatmap The `PlayableBeatmap` whose difficulty will be calculated.
-     * @return The `Skill`s.
+     * @returns The `Skill`s.
      */
     protected abstract createSkills(beatmap: TBeatmap): Skill[];
     /**
      * Creates the `Skill`s to obtain the strain peaks of a `PlayableBeatmap`.
      *
-     * @param beatmap
+     * @param beatmap The `PlayableBeatmap` whose strain peaks will be calculated.
+     * @returns The `Skill`s.
      */
-    protected abstract createStrainPeakSkills(beatmap: TBeatmap): StrainSkill[];
+    protected abstract createStrainPeakSkills(beatmap: TBeatmap): (Skill & IHasPeakDifficulty)[];
     /**
      * Creates difficulty hitobjects for this calculator.
      *
@@ -492,12 +470,13 @@ declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, TH
     /**
      * Creates a `DifficultyAttributes` object to describe a `PlayableBeatmap`'s difficulty.
      *
-     * @param beatmap The `PlayableBeatmap` whose difficulty was calculated.
+     * @param beatmap The `Beatmap` whose difficulty was calculated.
+     * @param playableBeatmap The `PlayableBeatmap` whose difficulty was calculated.
      * @param skills The `Skill`s which processed the `PlayableBeatmap`.
      * @param objects The `DifficultyHitObject`s which were processed.
      * @returns The `DifficultyAttributes` object.
      */
-    protected abstract createDifficultyAttributes(beatmap: TBeatmap, skills: Skill[], objects: THitObject[]): TAttributes;
+    protected abstract createDifficultyAttributes(beatmap: Beatmap, playableBeatmap: TBeatmap, skills: Skill[], objects: THitObject[]): TAttributes;
     /**
      * Constructs a `PlayableBeatmap` from a `Beatmap` with specific `Mod`s.
      *
@@ -509,83 +488,159 @@ declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, TH
 }
 
 /**
- * Represents a slider that is considered difficult.
- *
- * This structure is a part of difficulty attributes and can be cached.
+ * Represents options for performance calculation.
  */
-interface DifficultSlider {
+interface PerformanceCalculationOptions {
     /**
-     * The index of the slider in the beatmap.
+     * The maximum combo achieved in the score.
      */
-    readonly index: number;
+    combo?: 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.
+     * The accuracy achieved in the score.
+     */
+    accPercent?: Accuracy | number;
+    /**
+     * The amount of misses achieved in the score.
      *
-     * A value closer to 0 indicates that this slider is easier compared to most sliders.
+     * If {@link accPercent} is provided as an {@link Accuracy} object, this value will be ignored.
      */
-    readonly difficultyRating: number;
+    miss?: number;
+    /**
+     * The amount of slider ends dropped in the score.
+     */
+    sliderEndsDropped?: number;
+    /**
+     * The amount of slider ticks missed in the score.
+     */
+    sliderTicksMissed?: number;
+    /**
+     * The tap penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
+     */
+    tapPenalty?: number;
+    /**
+     * The aim slider cheese penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
+     */
+    aimSliderCheesePenalty?: number;
+    /**
+     * The total score achieved in the score.
+     */
+    totalScore?: number;
 }
 
 /**
- * Represents an osu!droid hit object with difficulty calculation values.
+ * The base class of performance calculators.
  */
-declare class DroidDifficultyHitObject extends DifficultyHitObject {
+declare abstract class PerformanceCalculator<T extends IDifficultyAttributes> {
     /**
-     * The tap strain generated by the hitobject.
+     * The overall performance value.
      */
-    tapStrain: number;
+    total: number;
     /**
-     * The tap strain generated by the hitobject if `strainTime` isn't modified by
-     * OD. This is used in three-finger detection.
+     * The calculated accuracy.
      */
-    originalTapStrain: number;
+    computedAccuracy: Accuracy;
     /**
-     * The rhythm strain generated by the hitobject.
+     * The calculated maximum combo.
      */
-    rhythmStrain: number;
+    combo: number;
     /**
-     * The flashlight strain generated by the hitobject if sliders are considered.
+     * The difficulty attributes that is being calculated.
      */
-    flashlightStrainWithSliders: number;
+    readonly difficultyAttributes: T | CacheableDifficultyAttributes<T>;
     /**
-     * The flashlight strain generated by the hitobject if sliders are not considered.
+     * The mods that were used.
      */
-    flashlightStrainWithoutSliders: number;
+    protected readonly mods: ModMap;
+    private _sliderEndsDropped;
     /**
-     * The reading difficulty generated by the hitobject.
+     * The amount of slider ends dropped in the score.
      */
-    readingDifficulty: number;
+    protected get sliderEndsDropped(): number;
+    private _sliderTicksMissed;
+    /**
+     * The amount of slider ticks missed in the score.
+     *
+     * This is used to calculate the slider accuracy.
+     */
+    protected get sliderTicksMissed(): number;
+    private _usingClassicSliderAccuracy;
+    /**
+     * Whether this score uses classic slider accuracy.
+     */
+    protected get usingClassicSliderAccuracy(): boolean;
     /**
-     * The note density of the hitobject.
+     * @param difficultyAttributes The difficulty attributes to calculate.
      */
-    noteDensity: number;
+    constructor(difficultyAttributes: T | CacheableDifficultyAttributes<T>);
     /**
-     * The overlapping factor of the hitobject.
+     * Calculates the performance points of the beatmap.
      *
-     * This is used to scale visual skill.
+     * @param options Options for performance calculation.
+     * @returns The current instance.
      */
-    overlappingFactor: number;
+    calculate(options?: PerformanceCalculationOptions): this;
     /**
-     * Adjusted preempt time of the hitobject, taking speed multiplier into account.
+     * Returns a string representative of the class.
      */
-    readonly timePreempt: number;
-    private readonly radiusBuffThreshold;
-    protected readonly mode = Modes.droid;
-    protected readonly maximumSliderRadius: number;
-    get smallCircleBonus(): number;
+    abstract toString(): string;
     /**
-     * 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).
+     * Calculates all values that will be used for calculating the total
+     * performance value of the beatmap and stores them in this instance.
+     */
+    protected abstract calculateValues(): void;
+    /**
+     * The total hits that can be done in the beatmap.
+     */
+    protected get totalHits(): number;
+    /**
+     * The total hits that were successfully done.
+     */
+    protected get totalSuccessfulHits(): number;
+    /**
+     * The total of imperfect hits (100s, 50s, misses).
+     */
+    protected get totalImperfectHits(): number;
+    /**
+     * Processes given options for usage in performance calculation.
      *
-     * @param object The underlying hitobject.
-     * @param lastObject The hitobject before this hitobject.
-     * @param difficultyHitObjects All difficulty hitobjects in the processed beatmap.
-     * @param clockRate The clock rate of the beatmap.
+     * @param options Options for performance calculation.
      */
-    constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number, index: number);
-    opacityAt(time: number, mods: ModMap): number;
+    protected handleOptions(options?: PerformanceCalculationOptions): void;
+    /**
+     * Determines whether an attribute is a cacheable attribute.
+     *
+     * @param attributes The attributes to check.
+     * @returns Whether the attributes are cacheable.
+     */
+    private isCacheableAttribute;
+}
+
+/**
+ * Represents an osu!droid hit object with difficulty calculation values.
+ */
+declare class DroidDifficultyHitObject extends DifficultyHitObject {
+    /**
+     * The tap difficulty generated by the hitobject.
+     */
+    tapDifficulty: number;
+    /**
+     * The tap difficulty generated by the hitobject if `strainTime` isn't modified by
+     * OD. This is used in three-finger detection.
+     */
+    originalTapDifficulty: number;
+    /**
+     * The rhythm difficulty generated by the hitobject.
+     */
+    rhythmDifficulty: number;
+    /**
+     * The reading difficulty generated by the hitobject.
+     */
+    readingDifficulty: number;
+    readonly normalizedRadius = 50;
+    protected readonly mode = Modes.Droid;
+    protected get maximumSliderRadius(): number;
+    get smallCircleBonus(): number;
+    opacityAt(time: number, mods?: ModMap): number;
     previous(backwardsIndex: number): this | null;
     next(forwardsIndex: number): this | null;
     /**
@@ -604,87 +659,23 @@ declare class DroidDifficultyHitObject extends DifficultyHitObject {
 }
 
 /**
- * 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.
+ * Represents a slider that is considered difficult.
+ *
+ * This structure is a part of difficulty attributes and can be cached.
  */
-declare abstract class DroidSkill extends StrainSkill {
+interface DifficultSlider {
     /**
-     * The bonus multiplier that is given for a sequence of notes of equal difficulty.
+     * The index of the slider in the beatmap.
      */
-    protected abstract readonly starsPerDouble: number;
-    process(current: DifficultyHitObject): void;
-    difficultyValue(): number;
+    readonly index: number;
     /**
-     * Gets the strain of a hitobject.
+     * The difficulty rating of this slider compared to other sliders, based on the velocity of the slider.
      *
-     * @param current The hitobject to get the strain from.
-     * @returns The strain of the hitobject.
+     * 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.
      */
-    protected abstract getObjectStrain(current: DifficultyHitObject): number;
-    protected calculateCurrentSectionStart(current: DifficultyHitObject): number;
-}
-
-/**
- * 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 strainDecayBase = 0.15;
-    protected readonly reducedSectionCount = 10;
-    protected readonly reducedSectionBaseline = 0.75;
-    protected readonly starsPerDouble = 1.05;
-    private readonly skillMultiplier;
-    private currentAimStrain;
-    private readonly sliderStrains;
-    private maxSliderStrain;
-    readonly withSliders: boolean;
-    constructor(mods: ModMap, withSliders: boolean);
-    static difficultyToPerformance(difficulty: number): number;
-    /**
-     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
-     */
-    countDifficultSliders(): 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: DroidDifficultyHitObject): void;
-}
-
-/**
- * An evaluator for calculating osu!droid Aim skill.
- */
-declare abstract class DroidAimEvaluator {
-    private static readonly wideAngleMultiplier;
-    private static readonly acuteAngleMultiplier;
-    private static readonly sliderMultiplier;
-    private static readonly velocityChangeMultiplier;
-    private static readonly wiggleMultiplier;
-    private static readonly singleSpacingThreshold;
-    private static readonly minSpeedBonus;
-    /**
-     * 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: DroidDifficultyHitObject, withSliders: boolean): number;
-    /**
-     * Calculates the snap aim strain of a hitobject.
-     */
-    private static snapAimStrainOf;
-    /**
-     * Calculates the flow aim strain of a hitobject.
-     */
-    private static flowAimStrainOf;
-    private static calculateWideAngleBonus;
-    private static calculateAcuteAngleBonus;
+    readonly difficultyRating: number;
 }
 
 /**
@@ -707,26 +698,30 @@ interface IDroidDifficultyAttributes extends IDifficultyAttributes {
      * 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 notes that are considered difficult with respect to the reading skill.
      */
     readingDifficultNoteCount: number;
     /**
-     * The average delta time of speed objects.
+     * Describes how much of {@link aimDifficultStrainCount} is contributed to by circles or sliders.
+     *
+     * A value closer to 0 indicates most of {@link aimDifficultStrainCount} is contributed by circles.
+     *
+     * A value closer to infinity indicates most of {@link aimDifficultStrainCount} is contributed by sliders.
      */
-    averageSpeedDeltaTime: number;
+    aimTopWeightedSliderFactor: number;
     /**
-     * Describes how much of tap difficulty is contributed by notes that are "vibroable".
+     * Describes how much of {@link tapDifficultStrainCount} is contributed to by circles or sliders.
      *
-     * 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 {@link tapDifficultStrainCount} is contributed by circles.
      *
-     * A value closer to 0 indicates most of tap difficulty is contributed by notes that are "vibroable".
+     * A value closer to infinity indicates most of {@link tapDifficultStrainCount} is contributed by sliders.
+     */
+    tapTopWeightedSliderFactor: number;
+    /**
+     * The maximum score obtainable on the beatmap.
      */
-    vibroFactor: number;
+    maximumScore: number;
 }
 
 /**
@@ -734,13 +729,13 @@ interface IDroidDifficultyAttributes extends IDifficultyAttributes {
  */
 declare class DroidDifficultyAttributes extends DifficultyAttributes implements IDroidDifficultyAttributes {
     tapDifficulty: number;
-    rhythmDifficulty: number;
     readingDifficulty: number;
-    tapDifficultStrainCount: number;
-    flashlightDifficultStrainCount: number;
+    aimTopWeightedSliderFactor: number;
+    tapTopWeightedSliderFactor: number;
     readingDifficultNoteCount: number;
-    averageSpeedDeltaTime: number;
-    vibroFactor: number;
+    rhythmDifficulty: number;
+    tapDifficultStrainCount: number;
+    maximumScore: number;
     constructor(cacheableAttributes?: CacheableDifficultyAttributes<IDroidDifficultyAttributes>);
     toString(): string;
 }
@@ -806,209 +801,21 @@ declare class ExtendedDroidDifficultyAttributes extends DroidDifficultyAttribute
  * A difficulty calculator for osu!droid gamemode.
  */
 declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidPlayableBeatmap, DroidDifficultyHitObject, ExtendedDroidDifficultyAttributes> {
-    /**
-     * The strain threshold to start detecting for possible three-fingered section.
-     *
-     * Increasing this number will result in less sections being flagged.
-     */
-    static readonly threeFingerStrainThreshold = 175;
-    private readonly difficultyMultiplier;
     constructor();
     retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
-    protected createDifficultyAttributes(beatmap: DroidPlayableBeatmap, skills: Skill[], objects: DroidDifficultyHitObject[]): ExtendedDroidDifficultyAttributes;
+    protected createDifficultyAttributes(beatmap: Beatmap, playableBeatmap: DroidPlayableBeatmap, skills: Skill[], objects: DroidDifficultyHitObject[]): ExtendedDroidDifficultyAttributes;
     protected createPlayableBeatmap(beatmap: Beatmap, mods?: ModMap): DroidPlayableBeatmap;
     protected createDifficultyHitObjects(beatmap: DroidPlayableBeatmap): DroidDifficultyHitObject[];
     protected createSkills(beatmap: DroidPlayableBeatmap): Skill[];
-    protected createStrainPeakSkills(beatmap: DroidPlayableBeatmap): StrainSkill[];
+    protected createStrainPeakSkills(beatmap: DroidPlayableBeatmap): (Skill & IHasPeakDifficulty)[];
     private populateAimAttributes;
     private populateTapAttributes;
     private populateRhythmAttributes;
     private populateFlashlightAttributes;
     private populateReadingAttributes;
-    /**
-     * Calculates the base rating of a `Skill`.
-     *
-     * @param skill The `Skill` to calculate the rating of.
-     * @returns The rating of the `Skill`.
-     */
-    private calculateRating;
-}
-
-/**
- * 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 strainDecayBase = 0.15;
-    protected readonly reducedSectionCount = 0;
-    protected readonly reducedSectionBaseline = 1;
-    protected readonly starsPerDouble = 1.06;
-    private readonly skillMultiplier;
-    private currentFlashlightStrain;
-    readonly withSliders: boolean;
-    constructor(mods: ModMap, withSliders: boolean);
-    static difficultyToPerformance(difficulty: number): number;
-    protected strainValueAt(current: DroidDifficultyHitObject): number;
-    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
-    protected getObjectStrain(): number;
-    protected saveToHitObject(current: DroidDifficultyHitObject): void;
-    difficultyValue(): number;
-}
-
-/**
- * An evaluator for calculating osu!droid Flashlight skill.
- */
-declare abstract class DroidFlashlightEvaluator {
-    private static readonly maxOpacityBonus;
-    private static readonly hiddenBonus;
-    private static readonly traceableCircleBonus;
-    private static readonly traceableObjectBonus;
-    private static readonly minVelocity;
-    private static readonly sliderMultiplier;
-    private static readonly minAngleMultiplier;
-    /**
-     * Evaluates the difficulty of memorizing and hitting the current object, based on:
-     *
-     * - distance between a number of previous objects and the current object,
-     * - the visual opacity of the current object,
-     * - the angle made by the current object,
-     * - length and speed of the current object (for sliders),
-     * - and whether Hidden mod is enabled.
-     *
-     * @param current The current object.
-     * @param mods The mods used.
-     * @param withSliders Whether to take slider difficulty into account.
-     */
-    static evaluateDifficultyOf(current: DroidDifficultyHitObject, mods: ModMap, withSliders: boolean): number;
-}
-
-/**
- * Represents options for performance calculation.
- */
-interface PerformanceCalculationOptions {
-    /**
-     * The maximum combo achieved in the score.
-     */
-    combo?: number;
-    /**
-     * The accuracy achieved in the score.
-     */
-    accPercent?: Accuracy | number;
-    /**
-     * The amount of misses achieved in the score.
-     */
-    miss?: number;
-    /**
-     * The amount of slider ends dropped in the score.
-     */
-    sliderEndsDropped?: number;
-    /**
-     * The amount of slider ticks missed in the score.
-     */
-    sliderTicksMissed?: number;
-    /**
-     * The tap penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
-     */
-    tapPenalty?: number;
-    /**
-     * The aim slider cheese penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
-     */
-    aimSliderCheesePenalty?: number;
-    /**
-     * The flashlight slider cheese penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
-     */
-    flashlightSliderCheesePenalty?: number;
-    /**
-     * The visual slider cheese penalty to apply for penalized scores. Only used when using `DroidPerformanceCalculator`.
-     */
-    visualSliderCheesePenalty?: number;
-}
-
-/**
- * The base class of performance calculators.
- */
-declare abstract class PerformanceCalculator<T extends IDifficultyAttributes> {
-    /**
-     * The overall performance value.
-     */
-    total: number;
-    /**
-     * The calculated accuracy.
-     */
-    computedAccuracy: Accuracy;
-    /**
-     * The calculated maximum combo.
-     */
-    combo: number;
-    /**
-     * The difficulty attributes that is being calculated.
-     */
-    readonly difficultyAttributes: T | CacheableDifficultyAttributes<T>;
-    /**
-     * The mods that were used.
-     */
-    protected readonly mods: ModMap;
-    private _sliderEndsDropped;
-    /**
-     * The amount of slider ends dropped in the score.
-     */
-    protected get sliderEndsDropped(): number;
-    private _sliderTicksMissed;
-    /**
-     * The amount of slider ticks missed in the score.
-     *
-     * This is used to calculate the slider accuracy.
-     */
-    protected get sliderTicksMissed(): number;
-    private _usingClassicSliderAccuracy;
-    /**
-     * Whether this score uses classic slider accuracy.
-     */
-    protected get usingClassicSliderAccuracy(): boolean;
-    /**
-     * @param difficultyAttributes The difficulty attributes to calculate.
-     */
-    constructor(difficultyAttributes: T | CacheableDifficultyAttributes<T>);
-    /**
-     * Calculates the performance points of the beatmap.
-     *
-     * @param options Options for performance calculation.
-     * @returns The current instance.
-     */
-    calculate(options?: PerformanceCalculationOptions): this;
-    /**
-     * Returns a string representative of the class.
-     */
-    abstract toString(): string;
-    /**
-     * Calculates all values that will be used for calculating the total
-     * performance value of the beatmap and stores them in this instance.
-     */
-    protected abstract calculateValues(): void;
-    /**
-     * The total hits that can be done in the beatmap.
-     */
-    protected get totalHits(): number;
-    /**
-     * The total hits that were successfully done.
-     */
-    protected get totalSuccessfulHits(): number;
-    /**
-     * The total of imperfect hits (100s, 50s, misses).
-     */
-    protected get totalImperfectHits(): number;
-    /**
-     * Processes given options for usage in performance calculation.
-     *
-     * @param options Options for performance calculation.
-     */
-    protected handleOptions(options?: PerformanceCalculationOptions): void;
-    /**
-     * Determines whether an attribute is a cacheable attribute.
-     *
-     * @param attributes The attributes to check.
-     * @returns Whether the attributes are cacheable.
-     */
-    private isCacheableAttribute;
+    private calculateAimDifficultyRating;
+    private calculateDifficultyRating;
+    static sumCognitionDifficulty(reading: number, flashlight: number): number;
 }
 
 /**
@@ -1056,22 +863,21 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator<IDroidDif
      */
     get aimSliderCheesePenalty(): number;
     /**
-     * The penalty used to penalize the flashlight performance value.
-     *
-     * Can be properly obtained by analyzing the replay associated with the score.
+     * The total score achieved in the score.
      */
-    get flashlightSliderCheesePenalty(): number;
+    get totalScore(): number | null;
     /**
      * The amount of misses, including slider breaks.
      */
     get effectiveMissCount(): number;
     static readonly finalMultiplier = 1.24;
+    static readonly normExponent = 1.1;
     private _aimSliderCheesePenalty;
-    private _flashlightSliderCheesePenalty;
     private _tapPenalty;
     private _effectiveMissCount;
     private _deviation;
     private _tapDeviation;
+    private _totalScore;
     protected calculateValues(): void;
     protected handleOptions(options?: PerformanceCalculationOptions): void;
     /**
@@ -1129,111 +935,154 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator<IDroidDif
      *
      * Inaccuracies are capped to the number of circles in the map.
      */
-    private calculateDeviation;
+    private calculateAimDeviation;
     /**
-     * Does the same as {@link calculateDeviation}, but only for notes and inaccuracies that are relevant to tap difficulty.
+     * Does the same as {@link calculateAimDeviation}, but only for notes and inaccuracies that are relevant to tap difficulty.
      *
-     * Treats all difficult speed notes as circles, so this method can sometimes return a lower deviation than {@link calculateDeviation}.
+     * Treats all difficult speed notes as circles, so this method can sometimes return a lower deviation than {@link calculateAimDeviation}.
      * This is fine though, since this method is only used to scale tap pp.
      */
     private calculateTapDeviation;
     /**
-     * Calculates a multiplier for tap to account for improper tapping based on the deviation and tap difficulty.
+     * Estimates the player's tap deviation based on the OD, given number of greats, oks, mehs and misses,
+     * assuming the player's mean hit error is 0. The estimation is consistent in that two SS scores on the
+     * same map with the same settings will always return the same deviation.
      *
-     * [Graph](https://www.desmos.com/calculator/z5l9ebrwpi)
-     */
-    private calculateTapHighDeviationNerf;
+     * Misses are ignored because they are usually due to misaiming.
+     *
+     * Greats and oks are assumed to follow a normal distribution, whereas mehs are assumed to follow a uniform distribution.
+     */
+    private calculateDeviation;
+    /**
+     * Calculates a multiplier for tap to account for improper tapping based on the deviation and tap difficulty.
+     *
+     * [Graph](https://www.desmos.com/calculator/z5l9ebrwpi)
+     */
+    private calculateTapHighDeviationNerf;
     private getHitWindow;
+    private calculateEstimatedSliderBreaks;
+    private calculateMaximumComboBasedMissCount;
+    /**
+     * Calculates the amount of misses + sliderbreaks from combo.
+     */
+    private calculateComboBasedEstimatedMissCount;
     toString(): string;
 }
 
 /**
- * Represents the skill required to read every object in the map.
+ * An evaluator for calculating osu!droid agility aim difficulty.
  */
-declare class DroidReading extends Skill {
-    private readonly clockRate;
-    private readonly hitObjects;
-    private readonly noteDifficulties;
-    private readonly strainDecayBase;
-    private readonly skillMultiplier;
-    private currentNoteDifficulty;
-    private difficulty;
-    private noteWeightSum;
-    constructor(mods: ModMap, clockRate: number, hitObjects: readonly PlaceableHitObject[]);
+declare abstract class DroidAgilityEvaluator {
     /**
-     * Converts a difficulty value to a performance value.
+     * Evaluates the difficulty of fast aiming the current object.
      *
-     * @param difficulty The difficulty value to convert.
-     * @returns The performance value.
+     * @param current The current object.
      */
-    static difficultyToPerformance(difficulty: number): number;
-    process(current: DroidDifficultyHitObject): void;
-    difficultyValue(): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject): number;
+    private static highBpmBonus;
+}
+
+/**
+ * An evaluator for calculating osu!droid Flashlight skill.
+ */
+declare abstract class DroidFlashlightEvaluator {
+    private static readonly maxOpacityBonus;
+    private static readonly hiddenBonus;
+    private static readonly traceableCircleBonus;
+    private static readonly traceableObjectBonus;
+    private static readonly minVelocity;
+    private static readonly sliderMultiplier;
+    private static readonly minAngleMultiplier;
     /**
-     * Returns the number of relevant objects weighted against the top note.
+     * Evaluates the difficulty of memorizing and hitting the current object, based on:
+     *
+     * - distance between a number of previous objects and the current object,
+     * - the visual opacity of the current object,
+     * - the angle made by the current object,
+     * - length and speed of the current object (for sliders),
+     * - and whether Hidden mod is enabled.
+     *
+     * @param current The current object.
+     * @param mods The mods used.
      */
-    countTopWeightedNotes(): number;
-    private strainDecay;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, mods: ModMap): number;
+}
+
+/**
+ * An evaluator for calculating osu!droid flow aim difficulty.
+ */
+declare abstract class DroidFlowAimEvaluator {
+    private static readonly velocityChangeMultiplier;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, withSliders: boolean): number;
+    private static calculateOverlapFactor;
 }
 
 /**
- * An evaluator for calculating osu!droid reading skill.
+ * Evaluator for reading difficulty in osu!droid.
  */
 declare abstract class DroidReadingEvaluator {
-    private static readonly emptyModMap;
     private static readonly readingWindowSize;
-    private static readonly distanceInfluenceThreshold;
     private static readonly hiddenMultiplier;
+    private static readonly traceableMultiplier;
     private static readonly densityMultiplier;
     private static readonly densityDifficultyBase;
     private static readonly preemptBalancingFactor;
     private static readonly preemptStartingPoint;
-    static evaluateDifficultyOf(current: DroidDifficultyHitObject, clockRate: number, mods: ModMap): number;
+    private static readonly minimumAngleRelevancyTime;
+    private static readonly maximumAngleRelevancyTime;
     /**
-     * Retrieves a list of objects that are visible at the point in time the current object needs to be hit.
-     *
-     * @param current The current object.
+     * Evaluates the difficulty of reading the object.
      */
-    private static retrievePastVisibleObjects;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, mods: ModMap): number;
     /**
-     * Calculates the density of objects visible at the point in time the current object needs to be hit.
+     * Calculates the density difficulty of the current object and how hard it is to aim it because of it based on:
      *
-     * @param current The current object.
+     * - cursor velocity to the current object,
+     * - how many times the current object's angle was repeated,
+     * - density of objects visible when the current object appears, and
+     * - density of objects visible when the current object needs to be clicked.
      */
-    private static calculateCurrentVisibleObjectsDensity;
+    private static calculateDensityDifficulty;
     /**
-     * Returns the time an object spends invisible with the Hidden mod at the current approach rate.
+     * Calculates the difficulty of aiming the current object when the approach rate is very high based on:
      *
-     * @param current The current object.
+     * - cursor velocity to the current object,
+     * - how many times the current object's angle was repeated, and
+     * - how many milliseconds elapse between the approach circle appearing and touching the inner circle.
      */
-    private static getDurationSpentInvisible;
+    private static calculatePreemptDifficulty;
     /**
-     * Calculates a factor of how often the current object's angle has been repeated in a certain time frame.
-     * It does this by checking the difference in angle between current and past objects and sums them up
-     * based on a range of similarity.
+     * Calculates the difficulty of aiming the current object when the Hidden mod is active based on:
      *
-     * @param current The current object.
+     * - cursor velocity to the current object,
+     * - time the current object spends invisible,
+     * - density of objects visible when the current object appears,
+     * - density of objects visible when the current object needs to be clicked,
+     * - how many times the current object's angle was repeated, and
+     * - if the current object is perfectly stacked to the previous one.
+     */
+    private static calculateHiddenDifficulty;
+    private static calculateTraceableDifficulty;
+    private static getPastObjectDifficultyInfluence;
+    /**
+     * Returns a list of objects that are visible on screen at the point in time the current object becomes visible.
+     */
+    private static retrievePastVisibleObjects;
+    /**
+     * Returns the density of objects visible at the point in time the current object needs to be clicked capped by the reading window.
+     */
+    private static retrieveCurrentVisibleObjectDensity;
+    /**
+     * Returns a factor of how often the current object's angle has been repeated in a certain time frame.
+     * It does this by checking the difference in angle between current and past objects and sums them based on a range of similarity.
+     * https://www.desmos.com/calculator/eb057a4822
      */
     private static getConstantAngleNerfFactor;
+    /**
+     * Returns a nerfing factor for when objects are very distant in time, affecting reading less.
+     */
     private static getTimeNerfFactor;
-}
-
-/**
- * Represents the skill required to properly follow a beatmap's rhythm.
- */
-declare class DroidRhythm extends DroidSkill {
-    protected readonly reducedSectionCount = 5;
-    protected readonly reducedSectionBaseline = 0.75;
-    protected readonly strainDecayBase = 0.3;
-    protected readonly starsPerDouble = 1.75;
-    private readonly useSliderAccuracy;
-    private currentRhythmStrain;
-    private currentRhythmMultiplier;
-    constructor(mods: ModMap);
-    protected strainValueAt(current: DroidDifficultyHitObject): number;
-    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
-    protected getObjectStrain(): number;
-    protected saveToHitObject(current: DroidDifficultyHitObject): void;
+    private static highBpmBonus;
 }
 
 /**
@@ -1252,43 +1101,37 @@ declare abstract class DroidRhythmEvaluator {
      * @param useSliderAccuracy Whether to use slider accuracy.
      */
     static evaluateDifficultyOf(current: DroidDifficultyHitObject, useSliderAccuracy: boolean): number;
+    private static getEffectiveRatio;
 }
 
 /**
- * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
+ * An evaluator for calculating osu!droid snap aim difficulty.
  */
-declare class DroidTap extends DroidSkill {
-    protected readonly reducedSectionCount = 10;
-    protected readonly reducedSectionBaseline = 0.75;
-    protected readonly strainDecayBase = 0.3;
-    protected readonly starsPerDouble = 1.1;
-    private currentTapStrain;
-    private currentRhythmMultiplier;
-    private readonly skillMultiplier;
-    private readonly _objectDeltaTimes;
-    private maxStrain;
-    /**
-     * The delta time of hitobjects.
-     */
-    get objectDeltaTimes(): readonly number[];
-    readonly considerCheesability: boolean;
-    readonly strainTimeCap?: number;
-    constructor(mods: ModMap, considerCheesability: boolean, strainTimeCap?: number);
-    /**
-     * The amount of notes that are relevant to the difficulty.
-     */
-    relevantNoteCount(): number;
-    /**
-     * The delta time relevant to the difficulty.
-     */
-    relevantDeltaTime(): number;
-    protected strainValueAt(current: DroidDifficultyHitObject): number;
-    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
-    protected getObjectStrain(): number;
+declare abstract class DroidSnapAimEvaluator {
+    private static readonly wideAngleMultiplier;
+    private static readonly acuteAngleMultiplier;
+    private static readonly sliderMultiplier;
+    private static readonly velocityChangeMultiplier;
+    private static readonly wiggleMultiplier;
+    private static readonly angleRepetitionNoteLimit;
+    private static readonly maximumRepetitionNerf;
+    private static readonly maximumVectorInfluence;
     /**
-     * @param current The hitobject to save to.
+     * 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.
      */
-    protected saveToHitObject(current: DroidDifficultyHitObject): void;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, withSliders: boolean): number;
+    private static calculateWideAngleAcuteness;
+    static calculateAcuteAngleAcuteness(angle: number): number;
+    private static highBpmBonus;
+    private static calculateVectorAngleRepetition;
 }
 
 /**
@@ -1306,49 +1149,9 @@ declare abstract class DroidTapEvaluator {
      *
      * @param current 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: DroidDifficultyHitObject, considerCheesability: boolean, strainTimeCap?: number): number;
-}
-
-/**
- * Holds data that can be used to calculate osu!standard performance points.
- */
-interface IOsuDifficultyAttributes extends IDifficultyAttributes {
-    /**
-     * The perceived approach rate **exclusive** 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 health drain rate of the beatmap.
-     */
-    drainRate: 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;
-    /**
-     * Describes how much of {@link aimDifficultStrainCount} is contributed to by circles or sliders.
-     *
-     * A value closer to 0 indicates most of {@link aimDifficultStrainCount} is contributed by circles.
-     *
-     * A value closer to infinity indicates most of {@link aimDifficultStrainCount} is contributed by sliders.
-     */
-    aimTopWeightedSliderFactor: number;
-    /**
-     * Describes how much of {@link speedDifficultStrainCount} is contributed to by circles or sliders.
-     *
-     * A value closer to 0 indicates most of {@link speedDifficultStrainCount} is contributed by circles.
-     *
-     * A value closer to infinity indicates most of {@link speedDifficultStrainCount} is contributed by sliders.
      */
-    speedTopWeightedSliderFactor: number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, considerCheesability: boolean): number;
+    private static highBpmBonus;
 }
 
 /**
@@ -1359,53 +1162,9 @@ declare class OsuDifficultyHitObject extends DifficultyHitObject {
      * The speed strain generated by the hitobject.
      */
     speedStrain: number;
-    /**
-     * The flashlight strain generated by this hitobject.
-     */
-    flashlightStrain: number;
+    readonly normalizedRadius = 50;
     get smallCircleBonus(): number;
-    protected readonly mode = Modes.osu;
-}
-
-/**
- * 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 OsuSkill extends StrainSkill {
-    /**
-     * The weight by which each strain value decays.
-     */
-    protected abstract readonly decayWeight: number;
-    difficultyValue(): 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 sliderStrains;
-    readonly withSliders: boolean;
-    constructor(mods: ModMap, withSliders: boolean);
-    /**
-     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
-     */
-    countDifficultSliders(): number;
-    /**
-     * Obtains the amount of sliders that are considered difficult in terms of relative strain, weighted by consistency.
-     */
-    countTopWeightedSliders(): number;
-    protected strainValueAt(current: OsuDifficultyHitObject): number;
-    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
-    /**
-     * @param current The hitobject to save to.
-     */
-    protected saveToHitObject(current: OsuDifficultyHitObject): void;
+    protected readonly mode = Modes.Osu;
 }
 
 /**
@@ -1433,55 +1192,6 @@ declare abstract class OsuAimEvaluator {
     private static calculateAcuteAngleBonus;
 }
 
-/**
- * Holds data that can be used to calculate osu!standard performance points.
- */
-declare class OsuDifficultyAttributes extends DifficultyAttributes implements IOsuDifficultyAttributes {
-    approachRate: number;
-    drainRate: number;
-    speedDifficulty: number;
-    speedDifficultStrainCount: number;
-    aimTopWeightedSliderFactor: number;
-    speedTopWeightedSliderFactor: number;
-    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IOsuDifficultyAttributes>);
-    toString(): string;
-}
-
-/**
- * A difficulty calculator for osu!standard gamemode.
- */
-declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuPlayableBeatmap, OsuDifficultyHitObject, OsuDifficultyAttributes> {
-    private readonly starRatingMultiplier;
-    constructor();
-    retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
-    protected createDifficultyAttributes(beatmap: OsuPlayableBeatmap, skills: Skill[]): OsuDifficultyAttributes;
-    protected createPlayableBeatmap(beatmap: Beatmap, mods?: ModMap): OsuPlayableBeatmap;
-    protected createDifficultyHitObjects(beatmap: OsuPlayableBeatmap): OsuDifficultyHitObject[];
-    protected createSkills(beatmap: OsuPlayableBeatmap): OsuSkill[];
-    protected createStrainPeakSkills(beatmap: OsuPlayableBeatmap): StrainSkill[];
-    private calculateMechanicalDifficultyRating;
-    private calculateStarRating;
-    static calculateRateAdjustedApproachRate(approachRate: number, clockRate: number): number;
-    static calculateRateAdjustedOverallDifficulty(overallDifficulty: number, clockRate: number): 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 strainDecayBase = 0.15;
-    protected readonly reducedSectionCount = 0;
-    protected readonly reducedSectionBaseline = 1;
-    protected readonly decayWeight = 1;
-    private currentFlashlightStrain;
-    private readonly skillMultiplier;
-    static difficultyToPerformance(difficulty: number): number;
-    difficultyValue(): number;
-    protected strainValueAt(current: OsuDifficultyHitObject): number;
-    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
-    protected saveToHitObject(current: OsuDifficultyHitObject): void;
-}
-
 /**
  * An evaluator for calculating osu!standard Flashlight skill.
  */
@@ -1507,10 +1217,210 @@ declare abstract class OsuFlashlightEvaluator {
 }
 
 /**
- * A performance points calculator that calculates performance points for osu!standard gamemode.
+ * An evaluator for calculating osu!standard Rhythm skill.
  */
-declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficultyAttributes> {
-    /**
+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.
+     */
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
+}
+
+/**
+ * An evaluator for calculating osu!standard speed skill.
+ */
+declare abstract class OsuSpeedEvaluator {
+    private static readonly minSpeedBonus;
+    private static readonly DISTANCE_MULTIPLIER;
+    /**
+     * Evaluates the difficulty of tapping the current object, based on:
+     *
+     * - time between pressing the previous and current object,
+     * - distance between those objects,
+     * - and how easily they can be cheesed.
+     *
+     * @param current The current object.
+     * @param mods The mods applied.
+     */
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: ModMap): 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 implements IHasPeakDifficulty {
+    /**
+     * 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 readonly reducedSectionCount: number;
+    /**
+     * The baseline multiplier applied to the section with the biggest strain.
+     */
+    protected readonly reducedSectionBaseline: number;
+    protected readonly _objectStrains: number[];
+    /**
+     * The strains of hitobjects.
+     */
+    get objectStrains(): readonly number[];
+    protected readonly strainPeaks: number[];
+    get peaks(): readonly number[];
+    private readonly sectionLength;
+    private currentStrain;
+    private currentSectionPeak;
+    private currentSectionEnd;
+    /**
+     * Converts a difficulty value to a performance value.
+     *
+     * @param difficulty The difficulty value to convert.
+     * @returns The performance value.
+     */
+    static difficultyToPerformance(difficulty: number): number;
+    /**
+     * Obtains the live strain peaks for each {@link sectionLength} of the beatmap, including the peak of the current section.
+     */
+    get currentStrainPeaks(): number[];
+    /**
+     * 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.
+     *
+     * @param difficultyValue The final difficulty value.
+     */
+    countTopWeightedStrains(difficultyValue: number): number;
+    protected processInternal(current: DifficultyHitObject): 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;
+    /**
+     * 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;
+    /**
+     * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
+     */
+    private saveCurrentPeak;
+    /**
+     * 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 OsuSkill extends StrainSkill {
+    /**
+     * The weight by which each strain value decays.
+     */
+    protected abstract readonly decayWeight: number;
+    protected difficulty: number;
+    difficultyValue(): number;
+}
+
+/**
+ * Holds data that can be used to calculate osu!standard performance points.
+ */
+interface IOsuDifficultyAttributes extends IDifficultyAttributes {
+    /**
+     * The perceived approach rate **exclusive** 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 health drain rate of the beatmap.
+     */
+    drainRate: 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;
+    /**
+     * Describes how much of {@link aimDifficultStrainCount} is contributed to by circles or sliders.
+     *
+     * A value closer to 0 indicates most of {@link aimDifficultStrainCount} is contributed by circles.
+     *
+     * A value closer to infinity indicates most of {@link aimDifficultStrainCount} is contributed by sliders.
+     */
+    aimTopWeightedSliderFactor: number;
+    /**
+     * Describes how much of {@link speedDifficultStrainCount} is contributed to by circles or sliders.
+     *
+     * A value closer to 0 indicates most of {@link speedDifficultStrainCount} is contributed by circles.
+     *
+     * A value closer to infinity indicates most of {@link speedDifficultStrainCount} is contributed by sliders.
+     */
+    speedTopWeightedSliderFactor: number;
+}
+
+/**
+ * Holds data that can be used to calculate osu!standard performance points.
+ */
+declare class OsuDifficultyAttributes extends DifficultyAttributes implements IOsuDifficultyAttributes {
+    approachRate: number;
+    drainRate: number;
+    speedDifficulty: number;
+    speedDifficultStrainCount: number;
+    aimTopWeightedSliderFactor: number;
+    speedTopWeightedSliderFactor: number;
+    constructor(cacheableAttributes?: CacheableDifficultyAttributes<IOsuDifficultyAttributes>);
+    toString(): string;
+}
+
+/**
+ * A difficulty calculator for osu!standard gamemode.
+ */
+declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuPlayableBeatmap, OsuDifficultyHitObject, OsuDifficultyAttributes> {
+    private readonly starRatingMultiplier;
+    constructor();
+    retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
+    protected createDifficultyAttributes(_beatmap: Beatmap, playableBeatmap: OsuPlayableBeatmap, skills: Skill[]): OsuDifficultyAttributes;
+    protected createPlayableBeatmap(beatmap: Beatmap, mods?: ModMap): OsuPlayableBeatmap;
+    protected createDifficultyHitObjects(beatmap: OsuPlayableBeatmap): OsuDifficultyHitObject[];
+    protected createSkills(beatmap: OsuPlayableBeatmap): OsuSkill[];
+    protected createStrainPeakSkills(beatmap: OsuPlayableBeatmap): StrainSkill[];
+    private calculateMechanicalDifficultyRating;
+    private calculateStarRating;
+    static calculateRateAdjustedApproachRate(approachRate: number, clockRate: number): number;
+    static calculateRateAdjustedOverallDifficulty(overallDifficulty: number, clockRate: number): number;
+}
+
+/**
+ * A performance points calculator that calculates performance points for osu!standard gamemode.
+ */
+declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficultyAttributes> {
+    /**
      * The aim performance value.
      */
     aim: number;
@@ -1594,27 +1504,360 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficu
 }
 
 /**
- * An evaluator for calculating osu!standard Rhythm skill.
+ * Data class for variable length strain.
  */
-declare abstract class OsuRhythmEvaluator {
-    private static readonly historyTimeMax;
-    private static readonly historyObjectsMax;
-    private static readonly rhythmOverallMultiplier;
-    private static readonly rhythmRatioMultiplier;
+declare class StrainPeak {
+    readonly value: number;
+    readonly sectionLength: number;
+    constructor(value: number, sectionLength: number);
+    compareTo(other: StrainPeak): number;
+}
+
+/**
+ * A skill that evaluates strain over a variable length of time. A new strain peak is created for every
+ * {@link DifficultyHitObject}.
+ */
+declare abstract class VariableLengthStrainSkill extends Skill implements IHasPeakDifficulty {
     /**
-     * Calculates a rhythm multiplier for the difficulty of the tap associated
-     * with historic data of the current object.
+     * The weight by which each strain value decays.
+     */
+    protected readonly decayWeight: number;
+    /**
+     * The maximum length of a strain section, in milliseconds.
+     */
+    protected readonly maxSectionLength: number;
+    /**
+     * The number of {@link maxSectionLength} sections calculated such that enough of the difficulty value is preserved.
      *
-     * @param current The current object.
+     * This should be overridden if strains are ever used outside of {@link difficultyValue}, or if {@link difficultyValue}
+     * is overridden to not use the default geometric sum.
+     *
+     * This should be removed in the future when a better memory-saving technique is implemented.
      */
-    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
+    protected get maxStoredSections(): number;
+    private currentSectionPeak;
+    private currentSectionBegin;
+    private currentSectionEnd;
+    private totalLength;
+    private readonly strainPeaks;
+    get peaks(): readonly number[];
+    /**
+     * Stores previous strains so that, if a difficult {@link DifficultyHitObject} is followed by an easier
+     * {@link DifficultyHitObject}, the difficult one gets a full strain instead of being cut short.
+     */
+    private readonly queuedStrains;
+    static difficultyToPerformance(difficulty: number): number;
+    /**
+     * Obtains the live strain peaks for each {@link maxSectionLength} of the beatmap, including the
+     * peak of the current section.
+     */
+    get currentStrainPeaks(): StrainPeak[];
+    difficultyValue(): number;
+    /**
+     * 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.
+     */
+    countTopWeightedStrains(difficultyValue: number): number;
+    protected processInternal(current: DifficultyHitObject): number;
+    /**
+     * Calculates the strain value at the {@link DifficultyHitObject}. This value is calculated with or without respect to
+     * previous {@link DifficultyHitObject}s.
+     *
+     * @param current The {@link DifficultyHitObject} for which the strain value should be calculated.
+     */
+    protected abstract strainValueAt(current: DifficultyHitObject): number;
+    /**
+     * 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;
+    /**
+     * Fills the space between the end of the current section and the current {@link DifficultyHitObject}, if any.
+     *
+     * @param current The current {@link DifficultyHitObject}.
+     */
+    private backfillPeaks;
+    /**
+     * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
+     */
+    private saveCurrentPeak;
+    private startNewSectionFrom;
+    private addStrainPeakInPlace;
+}
+
+/**
+ * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
+ */
+declare class DroidAim extends VariableLengthStrainSkill {
+    private currentStrain;
+    private readonly skillMultiplierSnap;
+    private readonly skillMultiplierAgility;
+    private readonly skillMultiplierFlow;
+    private readonly skillMultiplierTotal;
+    private readonly combinedSnapNormExponent;
+    /**
+     * 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 beatmap.
+     */
+    private readonly reducedSectionTime;
+    /**
+     * The baseline multiplier applied to the section with the biggest strain.
+     */
+    private readonly reducedStrainBaseline;
+    private readonly sliderStrains;
+    private maxSliderStrain;
+    readonly withSliders: boolean;
+    constructor(mods: ModMap, withSliders: boolean);
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
+     */
+    countDifficultSliders(): number;
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain, weighted by consistency.
+     *
+     * @param difficultyValue The final difficulty value.
+     */
+    countTopWeightedSliders(difficultyValue: number): number;
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject, difficulty: number): void;
+    private calculateAdjustedDifficulty;
+    private calculateTotalValue;
+    /**
+     * Converts the ratio of snap to flow into the probability of snapping or flowing.
+     *
+     * Constraints:
+     * - `P(snap) + P(flow) = 1` (the object is always either snapped or flowed)
+     * - `P(snap) = f(snap / flow)` and `P(flow) = f(flow/snap)` (i.e., snap and flow are symmetric and
+     * reversible). This means `f(x) + f(1/x) = 1`
+     * - `0 <= f(x) <= 1` (cannot have negative or greater than 100% probability of snapping or flowing)
+     *
+     * This logistic function is a solution, which fits nicely with the general idea of interpolation and
+     * provides a tuneable constant.
+     *
+     * @param ratio The ratio.
+     * @returns The probability.
+     */
+    private calculateSnapFlowProbability;
+    difficultyValue(): number;
+    private getReducedStrainPeaks;
+    private strainDecay;
+}
+
+/**
+ * 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;
+    protected difficulty: number;
+    process(current: DifficultyHitObject): void;
+    difficultyValue(): number;
+    /**
+     * Gets the strain of a hitobject.
+     *
+     * @param current The hitobject to get the strain from.
+     * @returns The strain of the hitobject.
+     */
+    protected abstract getObjectStrain(current: DifficultyHitObject): number;
+    protected calculateCurrentSectionStart(current: DifficultyHitObject): number;
+}
+
+/**
+ * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
+ */
+declare class DroidFlashlight extends DroidSkill {
+    private readonly totalObjects;
+    protected readonly reducedSectionCount = 0;
+    protected readonly reducedSectionBaseline = 1;
+    protected readonly starsPerDouble = 1.06;
+    private readonly skillMultiplier;
+    private currentFlashlightStrain;
+    static difficultyToPerformance(difficulty: number): number;
+    constructor(mods: ModMap, totalObjects: number);
+    protected strainValueAt(current: DroidDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
+    protected getObjectStrain(): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
+    difficultyValue(): number;
+    private calculateAdjustedDifficulty;
+    private strainDecay;
+}
+
+/**
+ * A skill that calculates the difficulty of {@link DifficultyHitObject}s using harmonic summation.
+ */
+declare abstract class HarmonicSkill extends Skill implements IHasPeakDifficulty {
+    private _noteWeightSum;
+    /**
+     * The sum of note weights, calculated during summation.
+     *
+     * Required for any calculations that normalizes the difficulty value.
+     */
+    protected get noteWeightSum(): number;
+    /**
+     * Scaling factor applied as `x / (i + 1)`, where `x` is the skill's {@link harmonicScale} and `i`
+     * is the index of the {@link DifficultyHitObject} being processed.
+     *
+     * A higher value increases the influence of the hardest {@link DifficultyHitObject}s during summation.
+     */
+    protected readonly harmonicScale: number;
+    /**
+     * An exponent that controls the rate of which decay increases as the index increases.
+     *
+     * Values closer to 1 decay faster, whilst lower values give more weight to easier {@link DifficultyHitObject}s.
+     */
+    protected readonly decayExponent: number;
+    get peaks(): readonly number[];
+    static difficultyToPerformance(difficulty: number): number;
+    difficultyValue(): number;
+    /**
+     * Calculates the amount of object difficulties weighed against the top object difficulty.
+     *
+     * @param difficultyValue The final difficulty value.
+     */
+    countTopWeightedObjectDifficulties(difficultyValue: number): number;
+    /**
+     * Transforms the difficulties of {@link DifficultyHitObject}s before they are summed together.
+     *
+     * This can be used to decrease weight of certain {@link DifficultyHitObject}s based on a skill-specific criteria.
+     *
+     * @param difficulties The difficulties of {@link DifficultyHitObject}s to transform.
+     */
+    protected applyDifficultyTransformation(difficulties: number[]): void;
+    protected processInternal(current: DifficultyHitObject): number;
+    /**
+     * Calculates the difficulty value of a {@link DifficultyHitObject}. This value is calculated with or without respect to previous objects.
+     *
+     * @param current The {@link DifficultyHitObject} for which the difficulty value should be calculated.
+     */
+    protected abstract objectDifficultyOf(current: DifficultyHitObject): number;
+}
+
+/**
+ * Represents the skill required to read every object in the beatmap.
+ */
+declare class DroidReading extends HarmonicSkill {
+    private readonly clockRate;
+    private readonly hitObjects;
+    private currentDifficulty;
+    private readonly skillMultiplier;
+    private readonly difficultyDecayBase;
+    constructor(mods: ModMap, clockRate: number, hitObjects: readonly PlaceableHitObject[]);
+    countTopWeightedObjectDifficulties(difficultyValue: number): number;
+    protected objectDifficultyOf(current: DroidDifficultyHitObject): number;
+    protected applyDifficultyTransformation(difficulties: number[]): void;
+    protected saveToHitObject(current: DroidDifficultyHitObject, difficulty: number): void;
+    private calculateAdjustedDifficulty;
+    private calculateReducedNoteCount;
+    private difficultyDecay;
+}
+
+/**
+ * Represents the skill required to properly follow a beatmap's rhythm.
+ */
+declare class DroidRhythm extends HarmonicSkill {
+    protected readonly harmonicScale = 25;
+    protected readonly decayExponent = 0.8;
+    private readonly skillMultiplier;
+    private readonly strainDecayBase;
+    private currentRhythmDifficulty;
+    private currentRhythmMultiplier;
+    private readonly useSliderAccuracy;
+    constructor(mods: ModMap);
+    protected objectDifficultyOf(current: DroidDifficultyHitObject): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
+    private strainDecay;
+}
+
+/**
+ * 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 HarmonicSkill {
+    protected readonly harmonicScale = 20;
+    private readonly skillMultiplier;
+    private readonly strainDecayBase;
+    private currentTapDifficulty;
+    private currentRhythmMultiplier;
+    private readonly sliderDifficulties;
+    private maxDifficulty;
+    readonly considerCheesability: boolean;
+    constructor(mods: ModMap, considerCheesability: boolean);
+    /**
+     * The amount of notes that are relevant to the difficulty.
+     */
+    relevantNoteCount(): number;
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative difficulty, weighted by consistency.
+     *
+     * @param difficultyValue The final difficulty value.
+     */
+    countTopWeightedSliders(difficultyValue: number): number;
+    protected objectDifficultyOf(current: DroidDifficultyHitObject): number;
+    protected saveToHitObject(current: DroidDifficultyHitObject): void;
+    private strainDecay;
+}
+
+/**
+ * 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 {
+    private readonly strainDecayBase;
+    protected readonly reducedSectionCount = 10;
+    protected readonly reducedSectionBaseline = 0.75;
+    protected readonly decayWeight = 0.9;
+    private currentAimStrain;
+    private readonly skillMultiplier;
+    private readonly sliderStrains;
+    readonly withSliders: boolean;
+    constructor(mods: ModMap, withSliders: boolean);
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
+     */
+    countDifficultSliders(): number;
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain, weighted by consistency.
+     */
+    countTopWeightedSliders(): number;
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
+    /**
+     * @param current The hitobject to save to.
+     */
+    protected saveToHitObject(current: OsuDifficultyHitObject, difficulty: number): void;
+    private strainDecay;
+}
+
+/**
+ * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
+ */
+declare class OsuFlashlight extends OsuSkill {
+    private readonly strainDecayBase;
+    protected readonly reducedSectionCount = 0;
+    protected readonly reducedSectionBaseline = 1;
+    protected readonly decayWeight = 1;
+    private currentFlashlightStrain;
+    private readonly skillMultiplier;
+    static difficultyToPerformance(difficulty: number): number;
+    difficultyValue(): number;
+    protected strainValueAt(current: OsuDifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
+    protected saveToHitObject(current: OsuDifficultyHitObject, difficulty: number): void;
+    private strainDecay;
 }
 
 /**
  * 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 strainDecayBase = 0.3;
+    private readonly strainDecayBase;
     protected readonly reducedSectionCount = 5;
     protected readonly reducedSectionBaseline = 0.75;
     protected readonly decayWeight = 0.9;
@@ -1639,33 +1882,9 @@ declare class OsuSpeed extends OsuSkill {
     /**
      * @param current The hitobject to save to.
      */
-    protected saveToHitObject(current: OsuDifficultyHitObject): void;
-}
-
-/**
- * An evaluator for calculating osu!standard speed skill.
- */
-declare abstract class OsuSpeedEvaluator {
-    /**
-     * Spacing threshold for a single hitobject spacing.
-     *
-     * About 1.25 circles distance between hitobject centers.
-     */
-    private static readonly SINGLE_SPACING_THRESHOLD;
-    private static readonly minSpeedBonus;
-    private static readonly DISTANCE_MULTIPLIER;
-    /**
-     * Evaluates the difficulty of tapping the current object, based on:
-     *
-     * - time between pressing the previous and current object,
-     * - distance between those objects,
-     * - and how easily they can be cheesed.
-     *
-     * @param current The current object.
-     * @param mods The mods applied.
-     */
-    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: ModMap): number;
+    protected saveToHitObject(current: OsuDifficultyHitObject, difficulty: number): void;
+    private strainDecay;
 }
 
-export { DifficultyAttributes, DifficultyCalculator, DifficultyHitObject, DroidAim, DroidAimEvaluator, DroidDifficultyAttributes, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidReading, DroidReadingEvaluator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, ExtendedDroidDifficultyAttributes, OsuAim, OsuAimEvaluator, OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, PerformanceCalculator };
+export { DifficultyAttributes, DifficultyCalculator, DifficultyHitObject, DroidAgilityEvaluator, DroidAim, DroidDifficultyAttributes, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidFlowAimEvaluator, DroidPerformanceCalculator, DroidReading, DroidReadingEvaluator, DroidRhythm, DroidRhythmEvaluator, DroidSnapAimEvaluator, DroidTap, DroidTapEvaluator, ExtendedDroidDifficultyAttributes, OsuAim, OsuAimEvaluator, OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, PerformanceCalculator };
 export type { CacheableDifficultyAttributes, DifficultSlider, HighStrainSection, IDifficultyAttributes, IDroidDifficultyAttributes, IExtendedDroidDifficultyAttributes, IOsuDifficultyAttributes, PerformanceCalculationOptions, StrainPeaks };