@rian8337/osu-difficulty-calculator 4.0.0-beta.50 → 4.0.0-beta.52

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.50",
+    "version": "4.0.0-beta.52",
     "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.48"
+        "@rian8337/osu-base": "^4.0.0-beta.52"
     },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "4a7163ab0b7a470d6df75087101a298514ab853b"
+    "gitHead": "c7cd2019227c891e7897245ee61d1e24d7a5fb9c"
 }

package/typings/index.d.ts

@@ -1,26 +1,5 @@
 import { Mod, PlaceableHitObject, Modes, Beatmap, Accuracy } from '@rian8337/osu-base';
 
-/**
- * An evaluator for calculating aim skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-declare abstract class AimEvaluator {
-    protected static readonly wideAngleMultiplier: number;
-    protected static readonly acuteAngleMultiplier: number;
-    protected static readonly sliderMultiplier: number;
-    protected static readonly velocityChangeMultiplier: number;
-    protected static readonly wiggleMultiplier: number;
-    /**
-     * Calculates the bonus of wide angles.
-     */
-    protected static calculateWideAngleBonus(angle: number): number;
-    /**
-     * Calculates the bonus of acute angles.
-     */
-    protected static calculateAcuteAngleBonus(angle: number): number;
-}
-
 /**
  * Holds data that can be used to calculate performance points.
  */
@@ -81,6 +60,10 @@ interface DifficultyAttributes {
      * 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.
      */
@@ -259,10 +242,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 isHidden Whether Hidden mod is used.
+     * @param mods The mods used.
      * @returns The opacity of the hitobject at the given time.
      */
-    opacityAt(time: number, isHidden: boolean): number;
+    opacityAt(time: number, mods: Mod[]): number;
     /**
      * How possible is it to doubletap this object together with the next one and get perfect
      * judgement in range from 0 to 1.
@@ -627,6 +610,7 @@ declare class DroidDifficultyHitObject extends DifficultyHitObject {
      */
     constructor(object: PlaceableHitObject, lastObject: PlaceableHitObject | null, lastLastObject: PlaceableHitObject | null, difficultyHitObjects: readonly DifficultyHitObject[], clockRate: number);
     computeProperties(clockRate: number, hitObjects: readonly PlaceableHitObject[]): void;
+    opacityAt(time: number, mods: Mod[]): number;
     /**
      * Determines whether this hitobject is considered overlapping with the hitobject before it.
      *
@@ -653,9 +637,9 @@ declare class DroidAim extends DroidSkill {
     protected readonly reducedSectionBaseline = 0.75;
     protected readonly starsPerDouble = 1.05;
     private readonly skillMultiplier;
-    private readonly withSliders;
     private currentAimStrain;
     private readonly sliderStrains;
+    readonly withSliders: boolean;
     constructor(mods: Mod[], withSliders: boolean);
     /**
      * Obtains the amount of sliders that are considered difficult in terms of relative strain.
@@ -673,11 +657,12 @@ declare class DroidAim extends DroidSkill {
 /**
  * An evaluator for calculating osu!droid Aim skill.
  */
-declare abstract class DroidAimEvaluator extends AimEvaluator {
-    protected static readonly wideAngleMultiplier = 1.5;
-    protected static readonly acuteAngleMultiplier = 2.6;
-    protected static readonly sliderMultiplier = 1.35;
-    protected static readonly velocityChangeMultiplier = 0.75;
+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;
     /**
@@ -700,18 +685,14 @@ declare abstract class DroidAimEvaluator extends AimEvaluator {
      * Calculates the flow aim strain of a hitobject.
      */
     private static flowAimStrainOf;
-    protected static calculateWideAngleBonus(angle: number): number;
-    protected static calculateAcuteAngleBonus(angle: number): number;
+    private static calculateWideAngleBonus;
+    private static calculateAcuteAngleBonus;
 }
 
 /**
  * Holds data that can be used to calculate osu!droid performance points.
  */
 interface DroidDifficultyAttributes extends DifficultyAttributes {
-    /**
-     * The number of sliders weighted by difficulty.
-     */
-    aimDifficultSliderCount: number;
     /**
      * The difficulty corresponding to the tap skill.
      */
@@ -933,9 +914,8 @@ declare class DroidFlashlight extends DroidSkill {
     protected readonly reducedSectionBaseline = 1;
     protected readonly starsPerDouble = 1.06;
     private readonly skillMultiplier;
-    private readonly isHidden;
-    private readonly withSliders;
     private currentFlashlightStrain;
+    readonly withSliders: boolean;
     constructor(mods: Mod[], withSliders: boolean);
     protected strainValueAt(current: DroidDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
@@ -944,23 +924,17 @@ declare class DroidFlashlight extends DroidSkill {
     difficultyValue(): number;
 }
 
-/**
- * An evaluator for calculating flashlight skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-declare abstract class FlashlightEvaluator {
-    protected static readonly maxOpacityBonus: number;
-    protected static readonly hiddenBonus: number;
-    protected static readonly minVelocity: number;
-    protected static readonly sliderMultiplier: number;
-    protected static readonly minAngleMultiplier: number;
-}
-
 /**
  * An evaluator for calculating osu!droid Flashlight skill.
  */
-declare abstract class DroidFlashlightEvaluator extends FlashlightEvaluator {
+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:
      *
@@ -971,10 +945,10 @@ declare abstract class DroidFlashlightEvaluator extends FlashlightEvaluator {
      * - and whether Hidden mod is enabled.
      *
      * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
+     * @param mods The mods used.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: DroidDifficultyHitObject, isHiddenMod: boolean, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, mods: Mod[], withSliders: boolean): number;
 }
 
 /**
@@ -1321,13 +1295,13 @@ declare class DroidTap extends DroidSkill {
     private currentTapStrain;
     private currentRhythmMultiplier;
     private readonly skillMultiplier;
-    private readonly considerCheesability;
-    private readonly strainTimeCap?;
     private readonly _objectDeltaTimes;
     /**
      * The delta time of hitobjects.
      */
     get objectDeltaTimes(): readonly number[];
+    readonly considerCheesability: boolean;
+    private readonly strainTimeCap?;
     constructor(mods: Mod[], considerCheesability: boolean, strainTimeCap?: number);
     /**
      * The amount of notes that are relevant to the difficulty.
@@ -1346,19 +1320,11 @@ declare class DroidTap extends DroidSkill {
     protected saveToHitObject(current: DroidDifficultyHitObject): void;
 }
 
-/**
- * An evaluator for calculating speed or tap skill.
- *
- * This class should be considered an "evaluating" class and not persisted.
- */
-declare abstract class SpeedEvaluator {
-    protected static readonly minSpeedBonus: number;
-}
-
 /**
  * An evaluator for calculating osu!droid tap skill.
  */
-declare abstract class DroidTapEvaluator extends SpeedEvaluator {
+declare abstract class DroidTapEvaluator {
+    private static readonly minSpeedBonus;
     /**
      * Evaluates the difficulty of tapping the current object, based on:
      *
@@ -1383,11 +1349,10 @@ declare class DroidVisual extends DroidSkill {
     protected readonly reducedSectionCount = 10;
     protected readonly reducedSectionBaseline = 0.75;
     protected readonly strainDecayBase = 0.1;
-    private readonly isHidden;
-    private readonly withSliders;
     private currentVisualStrain;
     private currentRhythmMultiplier;
     private readonly skillMultiplier;
+    readonly withSliders: boolean;
     constructor(mods: Mod[], withSliders: boolean);
     protected strainValueAt(current: DroidDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: DroidDifficultyHitObject): number;
@@ -1411,10 +1376,10 @@ declare abstract class DroidVisualEvaluator {
      * - and whether the Hidden mod is enabled.
      *
      * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
+     * @param mods The mods used.
      * @param withSliders Whether to take slider difficulty into account.
      */
-    static evaluateDifficultyOf(current: DroidDifficultyHitObject, isHiddenMod: boolean, withSliders: boolean): number;
+    static evaluateDifficultyOf(current: DroidDifficultyHitObject, mods: Mod[], withSliders: boolean): number;
 }
 
 /**
@@ -1456,8 +1421,13 @@ declare class OsuAim extends OsuSkill {
     protected readonly decayWeight = 0.9;
     private currentAimStrain;
     private readonly skillMultiplier;
-    private readonly withSliders;
+    private readonly sliderStrains;
+    readonly withSliders: boolean;
     constructor(mods: Mod[], withSliders: boolean);
+    /**
+     * Obtains the amount of sliders that are considered difficult in terms of relative strain.
+     */
+    countDifficultSliders(): number;
     protected strainValueAt(current: OsuDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
     /**
@@ -1469,7 +1439,12 @@ declare class OsuAim extends OsuSkill {
 /**
  * An evaluator for calculating osu!standard Aim skill.
  */
-declare abstract class OsuAimEvaluator extends AimEvaluator {
+declare abstract class OsuAimEvaluator {
+    private static readonly wideAngleMultiplier;
+    private static readonly acuteAngleMultiplier;
+    private static readonly sliderMultiplier;
+    private static readonly velocityChangeMultiplier;
+    private static readonly wiggleMultiplier;
     /**
      * Evaluates the difficulty of aiming the current object, based on:
      *
@@ -1482,6 +1457,8 @@ declare abstract class OsuAimEvaluator extends AimEvaluator {
      * @param withSliders Whether to take slider difficulty into account.
      */
     static evaluateDifficultyOf(current: OsuDifficultyHitObject, withSliders: boolean): number;
+    private static calculateWideAngleBonus;
+    private static calculateAcuteAngleBonus;
 }
 
 /**
@@ -1555,10 +1532,6 @@ declare class OsuDifficultyCalculator extends DifficultyCalculator<OsuDifficulty
      * @param speedSkill The speed skill.
      */
     private postCalculateSpeed;
-    /**
-     * Calculates speed-related attributes.
-     */
-    private calculateSpeedAttributes;
     /**
      * Called after flashlight skill calculation.
      *
@@ -1577,8 +1550,6 @@ declare class OsuFlashlight extends OsuSkill {
     protected readonly decayWeight = 1;
     private currentFlashlightStrain;
     private readonly skillMultiplier;
-    private readonly isHidden;
-    constructor(mods: Mod[]);
     difficultyValue(): number;
     protected strainValueAt(current: OsuDifficultyHitObject): number;
     protected calculateInitialStrain(time: number, current: OsuDifficultyHitObject): number;
@@ -1588,7 +1559,12 @@ declare class OsuFlashlight extends OsuSkill {
 /**
  * An evaluator for calculating osu!standard Flashlight skill.
  */
-declare abstract class OsuFlashlightEvaluator extends FlashlightEvaluator {
+declare abstract class OsuFlashlightEvaluator {
+    private static readonly maxOpacityBonus;
+    private static readonly hiddenBonus;
+    private static readonly minVelocity;
+    private static readonly sliderMultiplier;
+    private static readonly minAngleMultiplier;
     /**
      * Evaluates the difficulty of memorizing and hitting the current object, based on:
      *
@@ -1599,9 +1575,9 @@ declare abstract class OsuFlashlightEvaluator extends FlashlightEvaluator {
      * - and whether Hidden mod is enabled.
      *
      * @param current The current object.
-     * @param isHiddenMod Whether the Hidden mod is enabled.
+     * @param mods The mods used.
      */
-    static evaluateDifficultyOf(current: OsuDifficultyHitObject, isHiddenMod: boolean): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: Mod[]): number;
 }
 
 /**
@@ -1627,6 +1603,7 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<OsuDifficul
     protected finalMultiplier: number;
     protected readonly mode = Modes.osu;
     private comboPenalty;
+    private speedDeviation;
     protected calculateValues(): void;
     protected calculateTotalValue(): number;
     protected handleOptions(options?: PerformanceCalculationOptions): void;
@@ -1646,6 +1623,28 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator<OsuDifficul
      * Calculates the flashlight performance value of the beatmap.
      */
     private calculateFlashlightValue;
+    /**
+     * Estimates a player's deviation on speed notes using {@link calculateDeviation}, assuming worst-case.
+     *
+     * Treats all speed notes as hit circles.
+     */
+    private calculateSpeedDeviation;
+    /**
+     * 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.
+     *
+     * 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 multiplier for speed to account for improper tapping based on the deviation and speed difficulty.
+     *
+     * [Graph](https://www.desmos.com/calculator/dmogdhzofn)
+     */
+    private calculateSpeedHighDeviationNerf;
     toString(): string;
 }
 
@@ -1691,13 +1690,14 @@ declare class OsuSpeed extends OsuSkill {
 /**
  * An evaluator for calculating osu!standard speed skill.
  */
-declare abstract class OsuSpeedEvaluator extends SpeedEvaluator {
+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:
@@ -1707,8 +1707,9 @@ declare abstract class OsuSpeedEvaluator extends SpeedEvaluator {
      * - and how easily they can be cheesed.
      *
      * @param current The current object.
+     * @param mods The mods applied.
      */
-    static evaluateDifficultyOf(current: OsuDifficultyHitObject): number;
+    static evaluateDifficultyOf(current: OsuDifficultyHitObject, mods: Mod[]): number;
 }
 
-export { AimEvaluator, type CacheableDifficultyAttributes, type DifficultSlider, type DifficultyAttributes, type DifficultyCalculationOptions, DifficultyCalculator, DifficultyHitObject, DroidAim, DroidAimEvaluator, type DroidDifficultyAttributes, type DroidDifficultyCalculationOptions, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, type ExtendedDroidDifficultyAttributes, FlashlightEvaluator, type HighStrainSection, OsuAim, OsuAimEvaluator, type OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, type PerformanceCalculationOptions, PerformanceCalculator, SpeedEvaluator, type StrainPeaks };
+export { type CacheableDifficultyAttributes, type DifficultSlider, type DifficultyAttributes, type DifficultyCalculationOptions, DifficultyCalculator, DifficultyHitObject, DroidAim, DroidAimEvaluator, type DroidDifficultyAttributes, type DroidDifficultyCalculationOptions, DroidDifficultyCalculator, DroidDifficultyHitObject, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, type ExtendedDroidDifficultyAttributes, type HighStrainSection, OsuAim, OsuAimEvaluator, type OsuDifficultyAttributes, OsuDifficultyCalculator, OsuDifficultyHitObject, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, type PerformanceCalculationOptions, PerformanceCalculator, type StrainPeaks };