@rian8337/osu-difficulty-calculator 4.0.0-beta.94 → 4.0.0-beta.95

package/typings/index.d.ts

@@ -26,6 +26,10 @@ declare abstract class DifficultyHitObject {
      * The flashlight strain generated by the hitobject.
      */
     flashlightStrain: number;
+    /**
+     * The reading difficulty generated by the hitobject.
+     */
+    readingDifficulty: number;
     /**
      * The rhythm multiplier generated by the hitobject. This is used to alter tap strain.
      */
@@ -249,6 +253,10 @@ interface IDifficultyAttributes {
      * The difficulty corresponding to the flashlight skill.
      */
     flashlightDifficulty: number;
+    /**
+     * The difficulty corresponding to the reading skill.
+     */
+    readingDifficulty: number;
     /**
      * The number of clickable objects weighted by difficulty.
      *
@@ -293,6 +301,18 @@ interface IDifficultyAttributes {
      * The amount of strains that are considered difficult with respect to the aim skill.
      */
     aimDifficultStrainCount: 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;
+    /**
+     * The amount of notes that are considered difficult with respect to the reading skill.
+     */
+    readingDifficultNoteCount: number;
 }
 
 /**
@@ -314,6 +334,7 @@ declare abstract class DifficultyAttributes implements IDifficultyAttributes {
     maxCombo: number;
     aimDifficulty: number;
     flashlightDifficulty: number;
+    readingDifficulty: number;
     speedNoteCount: number;
     sliderFactor: number;
     clockRate: number;
@@ -323,6 +344,8 @@ declare abstract class DifficultyAttributes implements IDifficultyAttributes {
     spinnerCount: number;
     aimDifficultSliderCount: number;
     aimDifficultStrainCount: number;
+    aimTopWeightedSliderFactor: number;
+    readingDifficultNoteCount: number;
     constructor(cacheableAttributes?: CacheableDifficultyAttributes<IDifficultyAttributes>);
     /**
      * Converts this `DifficultyAttributes` instance to an attribute structure that can be cached.
@@ -391,17 +414,10 @@ declare abstract class Skill {
      */
     protected readonly mods: ModMap;
     private _objectDifficulties;
-    private _objectTimes;
     /**
      * The difficulties of {@link DifficultyHitObject}s, populated by {@link Skill.process}.
      */
     protected get objectDifficulties(): readonly number[];
-    /**
-     * The start times of {@link DifficultyHitObject}s, populated by {@link Skill.process}.
-     *
-     * Indices correspond to {@link objectDifficulties}.
-     */
-    protected get objectTimes(): readonly number[];
     constructor(mods: ModMap);
     /**
      * Calculates the strain value of a hitobject and stores the value in it.
@@ -653,10 +669,6 @@ declare class DroidDifficultyHitObject extends DifficultyHitObject {
      * 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;
@@ -711,26 +723,10 @@ interface IDroidDifficultyAttributes extends IDifficultyAttributes {
      * The difficulty corresponding to the rhythm skill.
      */
     rhythmDifficulty: number;
-    /**
-     * The difficulty corresponding to the reading skill.
-     */
-    readingDifficulty: number;
     /**
      * The amount of strains that are considered difficult with respect to the tap skill.
      */
     tapDifficultStrainCount: number;
-    /**
-     * The amount of notes that are considered difficult with respect to the reading skill.
-     */
-    readingDifficultNoteCount: 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 tapDifficultStrainCount} is contributed to by circles or sliders.
      *
@@ -750,10 +746,7 @@ interface IDroidDifficultyAttributes extends IDifficultyAttributes {
  */
 declare class DroidDifficultyAttributes extends DifficultyAttributes implements IDroidDifficultyAttributes {
     tapDifficulty: number;
-    readingDifficulty: number;
-    aimTopWeightedSliderFactor: number;
     tapTopWeightedSliderFactor: number;
-    readingDifficultNoteCount: number;
     rhythmDifficulty: number;
     tapDifficultStrainCount: number;
     maximumScore: number;
@@ -1176,32 +1169,21 @@ declare class OsuDifficultyHitObject extends DifficultyHitObject {
     speedStrain: number;
     readonly normalizedRadius = 50;
     get smallCircleBonus(): number;
+    get overallDifficulty(): number;
     protected readonly mode = Modes.Osu;
 }
 
 /**
- * An evaluator for calculating osu!standard Aim skill.
+ * An evaluator for calculating osu!standard agility aim difficulty.
  */
-declare abstract class OsuAimEvaluator {
-    private static readonly wideAngleMultiplier;
-    private static readonly acuteAngleMultiplier;
-    private static readonly sliderMultiplier;
-    private static readonly velocityChangeMultiplier;
-    private static readonly wiggleMultiplier;
+declare abstract class OsuAgilityEvaluator {
     /**
-     * Evaluates the difficulty of aiming the current object, based on:
-     *
-     * - cursor velocity to the current object,
-     * - angle difficulty,
-     * - sharp velocity increases,
-     * - and slider difficulty.
+     * Evaluates the difficulty of fast aiming the current object.
      *
      * @param current The current object.
-     * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: OsuDifficultyHitObject, withSliders: boolean): number;
-    private static calculateWideAngleBonus;
-    private static calculateAcuteAngleBonus;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
+    private static highBpmBonus;
 }
 
 /**
@@ -1229,132 +1211,143 @@ declare abstract class OsuFlashlightEvaluator {
 }
 
 /**
- * An evaluator for calculating osu!standard Rhythm skill.
+ * An evaluator for calculating osu!standard flow aim difficulty.
  */
-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;
+declare abstract class OsuFlowAimEvaluator {
+    private static readonly velocityChangeMultiplier;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, withSliders: boolean): number;
+    private static calculateOverlapFactor;
 }
 
 /**
- * An evaluator for calculating osu!standard speed skill.
+ * Evaluator for reading difficulty in osu!standard.
  */
-declare abstract class OsuSpeedEvaluator {
-    private static readonly minSpeedBonus;
-    private static readonly DISTANCE_MULTIPLIER;
+declare abstract class OsuReadingEvaluator {
+    private static readonly readingWindowSize;
+    private static readonly hiddenMultiplier;
+    private static readonly densityMultiplier;
+    private static readonly densityDifficultyBase;
+    private static readonly preemptBalancingFactor;
+    private static readonly preemptStartingPoint;
+    private static readonly minimumAngleRelevancyTime;
+    private static readonly maximumAngleRelevancyTime;
     /**
-     * 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.
+     * Evaluates the difficulty of reading the object.
      */
     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.
+     * Calculates the density difficulty of the current object and how hard it is to aim it because of it based on:
+     *
+     * - 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.
      */
-    protected readonly reducedSectionBaseline: number;
-    protected readonly _objectStrains: number[];
+    private static calculateDensityDifficulty;
     /**
-     * The strains of hitobjects.
+     * Calculates the difficulty of aiming the current object when the approach rate is very high based on:
+     *
+     * - 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.
      */
-    get objectStrains(): readonly number[];
-    protected readonly strainPeaks: number[];
-    private readonly strainPeakTimes;
-    get peaks(): readonly TimedStrainPeak[];
-    private readonly sectionLength;
-    private currentStrain;
-    private currentSectionPeak;
-    private currentSectionEnd;
+    private static calculatePreemptDifficulty;
     /**
-     * Converts a difficulty value to a performance value.
+     * Calculates the difficulty of aiming the current object when the Hidden mod is active based on:
      *
-     * @param difficulty The difficulty value to convert.
-     * @returns The performance value.
+     * - 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.
      */
-    static difficultyToPerformance(difficulty: number): number;
+    private static calculateHiddenDifficulty;
+    private static getPastObjectDifficultyInfluence;
     /**
-     * Obtains the live strain peaks for each {@link sectionLength} of the beatmap, including the peak of the current section.
+     * Returns a list of objects that are visible on screen at the point in time the current object becomes visible.
      */
-    get currentStrainPeaks(): number[];
+    private static retrievePastVisibleObjects;
     /**
-     * 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.
+     * Returns the density of objects visible at the point in time the current object needs to be clicked capped by the reading window.
      */
-    countTopWeightedStrains(difficultyValue: number): number;
-    protected processInternal(current: DifficultyHitObject): number;
+    private static retrieveCurrentVisibleObjectDensity;
     /**
-     * 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.
+     * 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
      */
-    protected calculateCurrentSectionStart(current: DifficultyHitObject): number;
+    private static getConstantAngleNerfFactor;
     /**
-     * Calculates the strain value at a hitobject.
-     *
-     * @param current The hitobject to calculate.
+     * Returns a nerfing factor for when objects are very distant in time, affecting reading less.
      */
-    protected abstract strainValueAt(current: DifficultyHitObject): number;
+    private static getTimeNerfFactor;
+    private static highBpmBonus;
+}
+
+/**
+ * An evaluator for calculating osu!standard Rhythm skill.
+ */
+declare abstract class OsuRhythmEvaluator {
+    private static readonly historyTimeMax;
+    private static readonly historyObjectsMax;
+    private static readonly rhythmOverallMultiplier;
+    private static readonly rhythmRatioMultiplier;
     /**
-     * Retrieves the peak strain at a point in time.
+     * Calculates a rhythm multiplier for the difficulty of the tap associated
+     * with historic data of the current object.
      *
-     * @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.
+     * @param current The current object.
      */
-    private saveCurrentPeak;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
+    private static getEffectiveRatio;
+}
+
+/**
+ * An evaluator for calculating osu!standard snap aim difficulty.
+ */
+declare abstract class OsuSnapAimEvaluator {
+    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;
     /**
-     * Sets the initial strain level for a new section.
+     * Evaluates the difficulty of aiming the current object, based on:
      *
-     * @param time The beginning of the new section in milliseconds.
-     * @param current The current hitobject.
+     * - 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.
      */
-    private startNewSectionFrom;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, withSliders: boolean): number;
+    private static calculateWideAngleAcuteness;
+    static calculateAcuteAngleAcuteness(angle: number): number;
+    private static highBpmBonus;
+    private static calculateVectorAngleRepetition;
 }
 
 /**
- * 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.
+ * An evaluator for calculating osu!standard speed skill.
  */
-declare abstract class OsuSkill extends StrainSkill {
+declare abstract class OsuSpeedEvaluator {
+    private static readonly minSpeedBonus;
     /**
-     * The weight by which each strain value decays.
+     * Evaluates the difficulty of tapping the current object, based on:
+     *
+     * - time between pressing the previous and current object,
+     * - and how easily they can be cheesed.
+     *
+     * @param current The current object.
      */
-    protected abstract readonly decayWeight: number;
-    protected difficulty: number;
-    difficultyValue(): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
+    private static highBpmBonus;
 }
 
 /**
@@ -1405,7 +1398,6 @@ declare class OsuDifficultyAttributes extends DifficultyAttributes implements IO
     drainRate: number;
     speedDifficulty: number;
     speedDifficultStrainCount: number;
-    aimTopWeightedSliderFactor: number;
     speedTopWeightedSliderFactor: number;
     constructor(cacheableAttributes?: CacheableDifficultyAttributes<IOsuDifficultyAttributes>);
     toString(): string;
@@ -1415,18 +1407,17 @@ declare class OsuDifficultyAttributes extends DifficultyAttributes implements IO
  * 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 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;
+    protected createSkills(beatmap: OsuPlayableBeatmap): Skill[];
+    protected createStrainPeakSkills(beatmap: OsuPlayableBeatmap): (Skill & IHasPeakDifficulty)[];
+    private calculateAimDifficultyRating;
+    private calculateDifficultyRating;
     private calculateStarRating;
-    static calculateRateAdjustedApproachRate(approachRate: number, clockRate: number): number;
-    static calculateRateAdjustedOverallDifficulty(overallDifficulty: number, clockRate: number): number;
+    static sumCognitionDifficulty(reading: number, flashlight: number): number;
 }
 
 /**
@@ -1449,11 +1440,16 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficu
      * The flashlight performance value.
      */
     flashlight: number;
+    /**
+     * The reading performance value.
+     */
+    reading: number;
     /**
      * The amount of misses, including slider breaks.
      */
     get effectiveMissCount(): number;
-    static readonly finalMultiplier = 1.14;
+    static readonly finalMultiplier = 1.12;
+    static readonly normExponent = 1.1;
     private greatWindow;
     private okWindow;
     private mehWindow;
@@ -1478,6 +1474,10 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficu
      * Calculates the flashlight performance value of the beatmap.
      */
     private calculateFlashlightValue;
+    /**
+     * Calculates the reading performance value of the beatmap.
+     */
+    private calculateReadingValue;
     /**
      * Calculates a strain-based miss penalty.
      *
@@ -1513,6 +1513,8 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficu
      * Calculates the amount of misses + sliderbreaks from combo.
      */
     private calculateComboBasedEstimatedMissCount;
+    private calculateTraceableBonus;
+    private calculateRateAdjustedApproachRate;
     toString(): string;
 }
 
@@ -1667,6 +1669,86 @@ declare class DroidAim extends VariableLengthStrainSkill {
     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 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[];
+    private readonly strainPeakTimes;
+    get peaks(): readonly TimedStrainPeak[];
+    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.
@@ -1715,12 +1797,19 @@ declare class DroidFlashlight extends DroidSkill {
  */
 declare abstract class HarmonicSkill extends Skill implements IHasPeakDifficulty {
     private _noteWeightSum;
+    private _objectTimes;
     /**
      * The sum of note weights, calculated during summation.
      *
      * Required for any calculations that normalizes the difficulty value.
      */
     protected get noteWeightSum(): number;
+    /**
+     * The start times of {@link DifficultyHitObject}s, populated by {@link HarmonicSkill.process}.
+     *
+     * Indices correspond to {@link objectDifficulties}.
+     */
+    protected get objectTimes(): readonly 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.
@@ -1751,6 +1840,7 @@ declare abstract class HarmonicSkill extends Skill implements IHasPeakDifficulty
      * @param difficulties The difficulties of {@link DifficultyHitObject}s to transform.
      */
     protected applyDifficultyTransformation(difficulties: number[]): void;
+    process(current: DifficultyHitObject): 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.
@@ -1827,14 +1917,24 @@ declare class DroidTap extends HarmonicSkill {
 /**
  * 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;
+declare class OsuAim 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);
     /**
@@ -1843,67 +1943,114 @@ declare class OsuAim extends OsuSkill {
     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(): number;
+    countTopWeightedSliders(difficultyValue: number): number;
     protected strainValueAt(current: OsuDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
+    private calculateAdjustedDifficulty;
+    private calculateTotalValue;
     /**
-     * @param current The hitobject to save to.
+     * 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.
      */
-    protected saveToHitObject(current: OsuDifficultyHitObject, difficulty: number): void;
+    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 OsuSkill extends StrainSkill {
+    /**
+     * The weight by which each strain value decays.
+     */
+    protected abstract readonly decayWeight: number;
+    protected difficulty: number;
+    difficultyValue(): number;
+}
+
 /**
  * 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;
+    private readonly totalObjects;
     protected readonly reducedSectionCount = 0;
     protected readonly reducedSectionBaseline = 1;
     protected readonly decayWeight = 1;
     private currentFlashlightStrain;
     private readonly skillMultiplier;
     static difficultyToPerformance(difficulty: number): number;
+    constructor(mods: ModMap, totalObjects: number);
     difficultyValue(): number;
     protected strainValueAt(current: OsuDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
-    protected saveToHitObject(current: OsuDifficultyHitObject, difficulty: number): void;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
+    private calculateAdjustedDifficulty;
     private strainDecay;
 }
 
+/**
+ * Represents the skill required to read every object in the beatmap.
+ */
+declare class OsuReading 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: OsuDifficultyHitObject): number;
+    protected applyDifficultyTransformation(difficulties: number[]): void;
+    protected saveToHitObject(current: DifficultyHitObject, difficulty: number): void;
+    private calculateAdjustedDifficulty;
+    private calculateReducedNoteCount;
+    private difficultyDecay;
+}
+
 /**
  * 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 {
-    private readonly strainDecayBase;
-    protected readonly reducedSectionCount = 5;
-    protected readonly reducedSectionBaseline = 0.75;
-    protected readonly decayWeight = 0.9;
-    private currentSpeedStrain;
+declare class OsuSpeed extends HarmonicSkill {
+    protected readonly harmonicScale = 20;
+    private currentDifficulty;
     private currentRhythm;
     private readonly skillMultiplier;
-    private readonly sliderStrains;
-    private maxStrain;
+    private readonly strainDecayBase;
+    private readonly sliderDifficulties;
+    private maxDifficulty;
     /**
      * 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 strain, weighted by consistency.
-     */
-    countTopWeightedSliders(): number;
-    /**
-     * @param current The hitobject to calculate.
-     */
-    protected strainValueAt(current: OsuDifficultyHitObject): number;
-    protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
-    /**
-     * @param current The hitobject to save to.
+     * Obtains the amount of sliders that are considered difficult in terms of relative difficulty, weighted by consistency.
+     *
+     * @param difficultyValue The final difficulty value.
      */
-    protected saveToHitObject(current: OsuDifficultyHitObject, difficulty: number): void;
+    countTopWeightedSliders(difficultyValue: number): number;
+    protected objectDifficultyOf(current: OsuDifficultyHitObject): number;
+    protected saveToHitObject(current: OsuDifficultyHitObject): void;
+    private calculateAdjustedDifficulty;
     private strainDecay;
 }
 
-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 { DifficultyAttributes, DifficultyCalculator, DifficultyHitObject, DroidAgilityEvaluator, DroidAim, DroidDifficultyAttributes, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidFlowAimEvaluator, DroidPerformanceCalculator, DroidReading, DroidReadingEvaluator, DroidRhythm, DroidRhythmEvaluator, DroidSnapAimEvaluator, DroidTap, DroidTapEvaluator, ExtendedDroidDifficultyAttributes, OsuAgilityEvaluator, OsuAim, OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuFlowAimEvaluator, OsuPerformanceCalculator, OsuReading, OsuReadingEvaluator, OsuRhythmEvaluator, OsuSnapAimEvaluator, OsuSpeed, OsuSpeedEvaluator, PerformanceCalculator };
 export type { CacheableDifficultyAttributes, DifficultSlider, HighStrainSection, IDifficultyAttributes, IDroidDifficultyAttributes, IExtendedDroidDifficultyAttributes, IOsuDifficultyAttributes, PerformanceCalculationOptions, StrainPeaks, TimedStrainPeak };