@rian8337/osu-difficulty-calculator 4.0.0-beta.83 → 4.0.0-beta.85

package/package.json

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

package/typings/index.d.ts

@@ -288,7 +288,7 @@ declare abstract class DifficultyHitObject {
      *
      * A value closer to 1 indicates a higher possibility.
      */
-    get doubletapness(): number;
+    getDoubletapness(nextObj: this | null): number;
     protected setDistances(clockRate: number): void;
     private calculateSliderCursorPosition;
     private getEndCursorPosition;
@@ -373,6 +373,13 @@ declare abstract class StrainSkill extends Skill {
     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;
     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.
@@ -428,7 +435,6 @@ declare abstract class StrainSkill extends Skill {
  * The base of a difficulty calculator.
  */
 declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, THitObject extends DifficultyHitObject, TAttributes extends DifficultyAttributes> {
-    protected abstract readonly difficultyMultiplier: number;
     /**
      * `Mod`s that adjust the difficulty of a beatmap.
      */
@@ -440,13 +446,6 @@ declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, TH
      * @returns The retained difficulty adjustment mods.
      */
     abstract retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
-    /**
-     * Calculates the difficulty of a `PlayableBeatmap`.
-     *
-     * @param beatmap The `PlayableBeatmap` whose difficulty is to be calculated.
-     * @returns A `DifficultyAttributes` object describing the difficulty of the `Beatmap`.
-     */
-    calculate(beatmap: TBeatmap): TAttributes;
     /**
      * Calculates the difficulty of a `Beatmap` with specific `Mod`s.
      *
@@ -507,20 +506,6 @@ declare abstract class DifficultyCalculator<TBeatmap extends PlayableBeatmap, TH
      * @returns The `PlayableBeatmap`.
      */
     protected abstract createPlayableBeatmap(beatmap: Beatmap, mods?: ModMap): TBeatmap;
-    /**
-     * Calculates the base rating of a `Skill`.
-     *
-     * @param skill The `Skill` to calculate the rating of.
-     * @returns The rating of the `Skill`.
-     */
-    protected calculateRating(skill: Skill): number;
-    /**
-     * Calculates the base performance value of a difficulty rating.
-     *
-     * @param rating The difficulty rating.
-     */
-    protected basePerformanceValue(rating: number): number;
-    private createPlayableBeatmapWithDifficultyAdjustmentMods;
 }
 
 /**
@@ -653,6 +638,7 @@ declare class DroidAim extends DroidSkill {
     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.
      */
@@ -826,7 +812,7 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidPlayab
      * Increasing this number will result in less sections being flagged.
      */
     static readonly threeFingerStrainThreshold = 175;
-    protected readonly difficultyMultiplier = 0.18;
+    private readonly difficultyMultiplier;
     constructor();
     retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
     protected createDifficultyAttributes(beatmap: DroidPlayableBeatmap, skills: Skill[], objects: DroidDifficultyHitObject[]): ExtendedDroidDifficultyAttributes;
@@ -839,6 +825,13 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator<DroidPlayab
     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;
 }
 
 /**
@@ -853,6 +846,7 @@ declare class DroidFlashlight extends DroidSkill {
     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;
@@ -953,39 +947,23 @@ declare abstract class PerformanceCalculator<T extends IDifficultyAttributes> {
      * The mods that were used.
      */
     protected readonly mods: ModMap;
-    /**
-     * The global multiplier to be applied to the final performance value.
-     *
-     * This is being adjusted to keep the final value scaled around what it used to be when changing things.
-     */
-    protected abstract finalMultiplier: number;
-    /**
-     * The gamemode to calculate for.
-     */
-    protected abstract readonly mode: Modes;
-    /**
-     * The amount of misses, including slider nested misses.
-     */
-    protected effectiveMissCount: number;
+    private _sliderEndsDropped;
     /**
      * The amount of slider ends dropped in the score.
      */
-    protected sliderEndsDropped: 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 sliderTicksMissed: number;
+    protected get sliderTicksMissed(): number;
     private _usingClassicSliderAccuracy;
     /**
      * Whether this score uses classic slider accuracy.
      */
     protected get usingClassicSliderAccuracy(): boolean;
-    /**
-     * Nerf factor used for nerfing beatmaps with very likely dropped sliderends.
-     */
-    protected sliderNerfFactor: number;
     /**
      * @param difficultyAttributes The difficulty attributes to calculate.
      */
@@ -1006,10 +984,6 @@ declare abstract class PerformanceCalculator<T extends IDifficultyAttributes> {
      * performance value of the beatmap and stores them in this instance.
      */
     protected abstract calculateValues(): void;
-    /**
-     * Calculates the total performance value of the beatmap and stores it in this instance.
-     */
-    protected abstract calculateTotalValue(): number;
     /**
      * The total hits that can be done in the beatmap.
      */
@@ -1022,28 +996,12 @@ declare abstract class PerformanceCalculator<T extends IDifficultyAttributes> {
      * The total of imperfect hits (100s, 50s, misses).
      */
     protected get totalImperfectHits(): number;
-    /**
-     * Calculates the base performance value of a star rating.
-     */
-    protected baseValue(stars: number): number;
     /**
      * Processes given options for usage in performance calculation.
      *
      * @param options Options for performance calculation.
      */
     protected handleOptions(options?: PerformanceCalculationOptions): void;
-    /**
-     * Calculates a strain-based miss penalty.
-     *
-     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
-     * so we use the amount of relatively difficult sections to adjust miss penalty
-     * to make it more punishing on maps with lower amount of hard sections.
-     */
-    protected calculateStrainBasedMissPenalty(difficultStrainCount: number): number;
-    /**
-     * Calculates the amount of misses + sliderbreaks from combo.
-     */
-    private calculateEffectiveMissCount;
     /**
      * Determines whether an attribute is a cacheable attribute.
      *
@@ -1103,39 +1061,18 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator<IDroidDif
      * Can be properly obtained by analyzing the replay associated with the score.
      */
     get flashlightSliderCheesePenalty(): number;
-    protected finalMultiplier: number;
-    protected readonly mode = Modes.droid;
+    /**
+     * The amount of misses, including slider breaks.
+     */
+    get effectiveMissCount(): number;
+    static readonly finalMultiplier = 1.24;
     private _aimSliderCheesePenalty;
     private _flashlightSliderCheesePenalty;
     private _tapPenalty;
+    private _effectiveMissCount;
     private _deviation;
     private _tapDeviation;
-    /**
-     * Applies a tap penalty value to this calculator.
-     *
-     * The tap and total performance value will be recalculated afterwards.
-     *
-     * @param value The tap penalty value. Must be greater than or equal to 1.
-     */
-    applyTapPenalty(value: number): void;
-    /**
-     * Applies an aim slider cheese penalty value to this calculator.
-     *
-     * The aim and total performance value will be recalculated afterwards.
-     *
-     * @param value The slider cheese penalty value. Must be between than 0 and 1.
-     */
-    applyAimSliderCheesePenalty(value: number): void;
-    /**
-     * Applies a flashlight slider cheese penalty value to this calculator.
-     *
-     * The flashlight and total performance value will be recalculated afterwards.
-     *
-     * @param value The slider cheese penalty value. Must be between 0 and 1.
-     */
-    applyFlashlightSliderCheesePenalty(value: number): void;
     protected calculateValues(): void;
-    protected calculateTotalValue(): number;
     protected handleOptions(options?: PerformanceCalculationOptions): void;
     /**
      * Calculates the aim performance value of the beatmap.
@@ -1157,6 +1094,14 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator<IDroidDif
      * Calculates the reading performance value of the beatmap.
      */
     private calculateReadingValue;
+    /**
+     * Calculates a strain-based miss penalty.
+     *
+     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
+     * so we use the amount of relatively difficult sections to adjust miss penalty
+     * to make it more punishing on maps with lower amount of hard sections.
+     */
+    private calculateStrainBasedMissPenalty;
     /**
      * The object-based proportional miss penalty.
      */
@@ -1215,6 +1160,13 @@ declare class DroidReading extends Skill {
     private difficulty;
     private noteWeightSum;
     constructor(mods: ModMap, clockRate: number, hitObjects: readonly PlaceableHitObject[]);
+    /**
+     * Converts a difficulty value to a performance value.
+     *
+     * @param difficulty The difficulty value to convert.
+     * @returns The performance value.
+     */
+    static difficultyToPerformance(difficulty: number): number;
     process(current: DroidDifficultyHitObject): void;
     difficultyValue(): number;
     /**
@@ -1369,6 +1321,10 @@ interface IOsuDifficultyAttributes extends IDifficultyAttributes {
      * 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.
      */
@@ -1377,6 +1333,22 @@ interface IOsuDifficultyAttributes extends IDifficultyAttributes {
      * 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;
 }
 
 /**
@@ -1424,6 +1396,10 @@ declare class OsuAim extends OsuSkill {
      * 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;
     /**
@@ -1462,8 +1438,11 @@ declare abstract class OsuAimEvaluator {
  */
 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;
 }
@@ -1472,7 +1451,7 @@ declare class OsuDifficultyAttributes extends DifficultyAttributes implements IO
  * A difficulty calculator for osu!standard gamemode.
  */
 declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuPlayableBeatmap, OsuDifficultyHitObject, OsuDifficultyAttributes> {
-    protected readonly difficultyMultiplier = 0.0675;
+    private readonly starRatingMultiplier;
     constructor();
     retainDifficultyAdjustmentMods(mods: Mod[]): Mod[];
     protected createDifficultyAttributes(beatmap: OsuPlayableBeatmap, skills: Skill[]): OsuDifficultyAttributes;
@@ -1480,9 +1459,10 @@ declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuPlayableBe
     protected createDifficultyHitObjects(beatmap: OsuPlayableBeatmap): OsuDifficultyHitObject[];
     protected createSkills(beatmap: OsuPlayableBeatmap): OsuSkill[];
     protected createStrainPeakSkills(beatmap: OsuPlayableBeatmap): StrainSkill[];
-    private populateAimAttributes;
-    private populateSpeedAttributes;
-    private populateFlashlightAttributes;
+    private calculateMechanicalDifficultyRating;
+    private calculateStarRating;
+    static calculateRateAdjustedApproachRate(approachRate: number, clockRate: number): number;
+    static calculateRateAdjustedOverallDifficulty(overallDifficulty: number, clockRate: number): number;
 }
 
 /**
@@ -1495,6 +1475,7 @@ declare class OsuFlashlight extends OsuSkill {
     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;
@@ -1545,13 +1526,14 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficu
      * The flashlight performance value.
      */
     flashlight: number;
-    protected finalMultiplier: number;
-    protected readonly mode = Modes.osu;
-    private comboPenalty;
+    /**
+     * The amount of misses, including slider breaks.
+     */
+    get effectiveMissCount(): number;
+    static readonly finalMultiplier = 1.14;
+    private _effectiveMissCount;
     private speedDeviation;
     protected calculateValues(): void;
-    protected calculateTotalValue(): number;
-    protected handleOptions(options?: PerformanceCalculationOptions): void;
     /**
      * Calculates the aim performance value of the beatmap.
      */
@@ -1568,6 +1550,14 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficu
      * Calculates the flashlight performance value of the beatmap.
      */
     private calculateFlashlightValue;
+    /**
+     * Calculates a strain-based miss penalty.
+     *
+     * Strain-based miss penalty assumes that a player will miss on the hardest parts of a map,
+     * so we use the amount of relatively difficult sections to adjust miss penalty
+     * to make it more punishing on maps with lower amount of hard sections.
+     */
+    private calculateMissPenalty;
     /**
      * Estimates a player's deviation on speed notes using {@link calculateDeviation}, assuming worst-case.
      *
@@ -1590,6 +1580,11 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<IOsuDifficu
      * [Graph](https://www.desmos.com/calculator/dmogdhzofn)
      */
     private calculateSpeedHighDeviationNerf;
+    private calculateEstimatedSliderBreaks;
+    /**
+     * Calculates the amount of misses + sliderbreaks from combo.
+     */
+    private calculateComboBasedEstimatedMissCount;
     toString(): string;
 }
 
@@ -1621,11 +1616,16 @@ declare class OsuSpeed extends OsuSkill {
     private currentSpeedStrain;
     private currentRhythm;
     private readonly skillMultiplier;
+    private readonly sliderStrains;
     private maxStrain;
     /**
      * 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.
      */