@rian8337/osu-difficulty-calculator 4.0.0-beta.11 → 4.0.0-beta.13

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-difficulty-calculator",
-    "version": "4.0.0-beta.11",
+    "version": "4.0.0-beta.13",
     "description": "A module for calculating osu!standard beatmap difficulty and performance value with respect to the current difficulty and performance algorithm.",
     "keywords": [
         "osu",
@@ -12,6 +12,9 @@
     "main": "dist/index.js",
     "types": "typings/index.d.ts",
     "typedocMain": "src/index.ts",
+    "engines": {
+        "node": ">=18"
+    },
     "files": [
         "dist/**",
         "typings/**"
@@ -23,17 +26,17 @@
     "scripts": {
         "build": "rollup -c ../../rollup.config.mjs",
         "lint": "eslint --ext ts",
-        "prepare": "npm run build",
+        "prepublishOnly": "npm run build",
         "test": "jest"
     },
     "bugs": {
         "url": "https://github.com/Rian8337/osu-droid-module/issues"
     },
     "dependencies": {
-        "@rian8337/osu-base": "^4.0.0-beta.11"
+        "@rian8337/osu-base": "^4.0.0-beta.13"
     },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "d8f913a87da4737c706d0b585663787670c729bf"
+    "gitHead": "e257d4c0d01722835ede297c9347a86668a4647c"
 }

package/typings/index.d.ts

@@ -295,6 +295,28 @@ declare class DifficultyHitObject {
     isOverlapping(considerDistance: boolean): boolean;
 }
 
+/**
+ * Represents the strain peaks of various calculated difficulties.
+ */
+interface StrainPeaks {
+    /**
+     * The strain peaks of aim difficulty if sliders are considered.
+     */
+    aimWithSliders: number[];
+    /**
+     * The strain peaks of aim difficulty if sliders are not considered.
+     */
+    aimWithoutSliders: number[];
+    /**
+     * The strain peaks of speed difficulty.
+     */
+    speed: number[];
+    /**
+     * The strain peaks of flashlight difficulty.
+     */
+    flashlight: number[];
+}
+
 /**
  * A bare minimal abstract skill for fully custom skill implementations.
  *
@@ -319,100 +341,7 @@ declare abstract class Skill {
 }
 
 /**
- * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
- * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
- */
-declare abstract class StrainSkill extends Skill {
-    /**
-     * The strain of currently calculated hitobject.
-     */
-    protected currentStrain: number;
-    /**
-     * The current section's strain peak.
-     */
-    protected currentSectionPeak: number;
-    /**
-     * Strain peaks are stored here.
-     */
-    readonly strainPeaks: number[];
-    /**
-     * The number of sections with the highest strains, which the peak strain reductions will apply to.
-     * This is done in order to decrease their impact on the overall difficulty of the map for this skill.
-     */
-    protected abstract readonly reducedSectionCount: number;
-    /**
-     * The baseline multiplier applied to the section with the biggest strain.
-     */
-    protected abstract readonly reducedSectionBaseline: number;
-    /**
-     * Strain values are multiplied by this number for the given skill. Used to balance the value of different skills between each other.
-     */
-    protected abstract readonly skillMultiplier: number;
-    /**
-     * Determines how quickly strain decays for the given skill.
-     *
-     * For example, a value of 0.15 indicates that strain decays to 15% of its original value in one second.
-     */
-    protected abstract readonly strainDecayBase: number;
-    private readonly sectionLength;
-    private currentSectionEnd;
-    /**
-     * Calculates the strain value of a hitobject and stores the value in it. This value is affected by previously processed objects.
-     *
-     * @param current The hitobject to process.
-     */
-    process(current: DifficultyHitObject): void;
-    /**
-     * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
-     */
-    saveCurrentPeak(): void;
-    /**
-     * Calculates strain decay for a specified time frame.
-     *
-     * @param ms The time frame to calculate.
-     */
-    protected strainDecay(ms: number): number;
-    /**
-     * Calculates the strain value at a hitobject.
-     */
-    protected abstract strainValueAt(current: DifficultyHitObject): number;
-    /**
-     * Saves the current strain to a hitobject.
-     */
-    protected abstract saveToHitObject(current: DifficultyHitObject): void;
-    /**
-     * Sets the initial strain level for a new section.
-     *
-     * @param offset The beginning of the new section in milliseconds, adjusted by speed multiplier.
-     * @param current The current hitobject.
-     */
-    private startNewSectionFrom;
-}
-
-/**
- * Represents the strain peaks of various calculated difficulties.
- */
-interface StrainPeaks {
-    /**
-     * The strain peaks of aim difficulty if sliders are considered.
-     */
-    aimWithSliders: number[];
-    /**
-     * The strain peaks of aim difficulty if sliders are not considered.
-     */
-    aimWithoutSliders: number[];
-    /**
-     * The strain peaks of speed difficulty.
-     */
-    speed: number[];
-    /**
-     * The strain peaks of flashlight difficulty.
-     */
-    flashlight: number[];
-}
-
-/**
- * The base of difficulty calculators.
+ * The base of a difficulty calculator.
  */
 declare abstract class DifficultyCalculator {
     /**
@@ -480,7 +409,7 @@ declare abstract class DifficultyCalculator {
      *
      * @param skills The skills to calculate.
      */
-    protected calculateSkills(...skills: StrainSkill[]): void;
+    protected calculateSkills(...skills: Skill[]): void;
     /**
      * Calculates the total star rating of the beatmap and stores it in this instance.
      */
@@ -496,7 +425,7 @@ declare abstract class DifficultyCalculator {
     /**
      * Creates skills to be calculated.
      */
-    protected abstract createSkills(): StrainSkill[];
+    protected abstract createSkills(): Skill[];
     /**
      * Populates the stored difficulty attributes with necessary data.
      */
@@ -586,6 +515,72 @@ interface DifficultSlider {
     readonly difficultyRating: number;
 }
 
+/**
+ * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
+ * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
+ */
+declare abstract class StrainSkill extends Skill {
+    /**
+     * Strain peaks are stored here.
+     */
+    readonly strainPeaks: number[];
+    /**
+     * The number of sections with the highest strains, which the peak strain reductions will apply to.
+     * This is done in order to decrease their impact on the overall difficulty of the map for this skill.
+     */
+    protected abstract readonly reducedSectionCount: number;
+    /**
+     * The baseline multiplier applied to the section with the biggest strain.
+     */
+    protected abstract readonly reducedSectionBaseline: number;
+    /**
+     * Determines how quickly strain decays for the given skill.
+     *
+     * For example, a value of 0.15 indicates that strain decays to 15% of its original value in one second.
+     */
+    protected abstract readonly strainDecayBase: number;
+    private readonly sectionLength;
+    private currentStrain;
+    private currentSectionPeak;
+    private currentSectionEnd;
+    process(current: DifficultyHitObject): void;
+    /**
+     * Saves the current peak strain level to the list of strain peaks, which will be used to calculate an overall difficulty.
+     */
+    saveCurrentPeak(): void;
+    /**
+     * Calculates strain decay for a specified time frame.
+     *
+     * @param ms The time frame to calculate.
+     */
+    protected strainDecay(ms: number): number;
+    /**
+     * Calculates the strain value at a hitobject.
+     *
+     * @param current The hitobject to calculate.
+     */
+    protected abstract strainValueAt(current: DifficultyHitObject): number;
+    /**
+     * Saves the current strain to a hitobject.
+     */
+    protected abstract saveToHitObject(current: DifficultyHitObject): void;
+    /**
+     * Retrieves the peak strain at a point in time.
+     *
+     * @param time The time to retrieve the peak strain at.
+     * @param current The current hit object.
+     * @returns The peak strain.
+     */
+    protected abstract calculateInitialStrain(time: number, current: DifficultyHitObject): number;
+    /**
+     * Sets the initial strain level for a new section.
+     *
+     * @param time The beginning of the new section in milliseconds.
+     * @param current The current hitobject.
+     */
+    private startNewSectionFrom;
+}
+
 /**
  * Used to processes strain values of difficulty hitobjects, keep track of strain levels caused by the processed objects
  * and to calculate a final difficulty value representing the difficulty of hitting all the processed objects.
@@ -602,17 +597,16 @@ declare abstract class DroidSkill extends StrainSkill {
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 declare class DroidAim extends DroidSkill {
-    protected readonly skillMultiplier: number;
     protected readonly strainDecayBase: number;
     protected readonly reducedSectionCount: number;
     protected readonly reducedSectionBaseline: number;
     protected readonly starsPerDouble: number;
+    private readonly skillMultiplier;
     private readonly withSliders;
+    private currentAimStrain;
     constructor(mods: Mod[], withSliders: boolean);
-    /**
-     * @param current The hitobject to calculate.
-     */
     protected strainValueAt(current: DifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
     /**
      * @param current The hitobject to save to.
      */
@@ -626,10 +620,7 @@ declare abstract class DroidAimEvaluator extends AimEvaluator {
     protected static readonly wideAngleMultiplier: number;
     protected static readonly sliderMultiplier: number;
     protected static readonly velocityChangeMultiplier: number;
-    /**
-     * Spacing threshold for a single hitobject spacing.
-     */
-    private static readonly SINGLE_SPACING_THRESHOLD;
+    private static readonly singleSpacingThreshold;
     private static readonly minSpeedBonus;
     /**
      * Evaluates the difficulty of aiming the current object, based on:
@@ -644,13 +635,13 @@ declare abstract class DroidAimEvaluator extends AimEvaluator {
      */
     static evaluateDifficultyOf(current: DifficultyHitObject, withSliders: boolean): number;
     /**
-     * Calculates the aim strain of a hitobject.
+     * Calculates the snap aim strain of a hitobject.
      */
-    private static aimStrainOf;
+    private static snapAimStrainOf;
     /**
-     * Calculates the movement strain of a hitobject.
+     * Calculates the flow aim strain of a hitobject.
      */
-    private static movementStrainOf;
+    private static flowAimStrainOf;
 }
 
 /**
@@ -818,13 +809,13 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator {
     /**
      * Called after tap skill calculation.
      *
-     * @param tapSkill The tap skill.
+     * @param tapSkillCheese The tap skill that considers cheesing.
      */
     private postCalculateTap;
     /**
-     * Calculates speed-related attributes.
+     * Calculates tap-related attributes.
      */
-    private calculateSpeedAttributes;
+    private calculateTapAttributes;
     /**
      * Calculates the sum of strains for possible three-fingered sections.
      *
@@ -859,18 +850,17 @@ declare class DroidDifficultyCalculator extends DifficultyCalculator {
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 declare class DroidFlashlight extends DroidSkill {
-    protected readonly skillMultiplier: number;
     protected readonly strainDecayBase: number;
     protected readonly reducedSectionCount: number;
     protected readonly reducedSectionBaseline: number;
     protected readonly starsPerDouble: number;
+    private readonly skillMultiplier;
     private readonly isHidden;
     private readonly withSliders;
+    private currentFlashlightStrain;
     constructor(mods: Mod[], withSliders: boolean);
-    /**
-     * @param current The hitobject to calculate.
-     */
     protected strainValueAt(current: DifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
     protected saveToHitObject(current: DifficultyHitObject): void;
     difficultyValue(): number;
 }
@@ -999,7 +989,7 @@ declare abstract class PerformanceCalculator {
     /**
      * Calculates the total performance value of the beatmap and stores it in this instance.
      */
-    protected abstract calculateTotalValue(): void;
+    protected abstract calculateTotalValue(): number;
     /**
      * The total hits that can be done in the beatmap.
      */
@@ -1126,7 +1116,7 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      */
     applyVisualSliderCheesePenalty(value: number): void;
     protected calculateValues(): void;
-    protected calculateTotalValue(): void;
+    protected calculateTotalValue(): number;
     protected handleOptions(options?: PerformanceCalculationOptions): void;
     /**
      * Calculates the aim performance value of the beatmap.
@@ -1149,13 +1139,26 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
      */
     private calculateVisualValue;
     /**
-     * Calculates miss penalty.
+     * Calculates a strain-based miss penalty.
      *
-     * Miss penalty assumes that a player will miss on the hardest parts of a map,
+     * 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;
+    private calculateStrainBasedMissPenalty;
+    /**
+     * The object-based proportional miss penalty.
+     */
+    private get proportionalMissPenalty();
+    /**
+     * Calculates the object-based length scaling based on the deviation of a player for a full
+     * combo in this beatmap, taking retries into account.
+     *
+     * @param objectCount The amount of objects to be considered. Defaults to the amount of
+     * objects in this beatmap.
+     * @param punishForMemorization Whether to punish the deviation for memorization. Defaults to `false`.
+     */
+    private calculateDeviationBasedLengthScaling;
     /**
      * Estimates the player's tap deviation based on the OD, number of circles and sliders,
      * and number of 300s, 100s, 50s, and misses, assuming the player's mean hit error is 0.
@@ -1185,15 +1188,16 @@ declare class DroidPerformanceCalculator extends PerformanceCalculator {
  * Represents the skill required to properly follow a beatmap's rhythm.
  */
 declare class DroidRhythm extends DroidSkill {
-    protected readonly skillMultiplier: number;
     protected readonly reducedSectionCount: number;
     protected readonly reducedSectionBaseline: number;
     protected readonly strainDecayBase: number;
     protected readonly starsPerDouble: number;
-    private currentRhythm;
+    private currentRhythmStrain;
+    private currentRhythmMultiplier;
     private readonly hitWindow;
     constructor(mods: Mod[], overallDifficulty: number);
     protected strainValueAt(current: DifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
     protected saveToHitObject(current: DifficultyHitObject): void;
 }
 
@@ -1225,19 +1229,18 @@ declare abstract class DroidRhythmEvaluator extends RhythmEvaluator {
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
 declare class DroidTap extends DroidSkill {
-    protected readonly skillMultiplier: number;
     protected readonly reducedSectionCount: number;
     protected readonly reducedSectionBaseline: number;
     protected readonly strainDecayBase: number;
     protected readonly starsPerDouble: number;
     private currentTapStrain;
-    private currentOriginalTapStrain;
+    private currentRhythmMultiplier;
+    private readonly skillMultiplier;
     private readonly greatWindow;
-    constructor(mods: Mod[], overallDifficulty: number);
-    /**
-     * @param current The hitobject to calculate.
-     */
+    private readonly considerCheesability;
+    constructor(mods: Mod[], overallDifficulty: number, considerCheesability: boolean);
     protected strainValueAt(current: DifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
     /**
      * @param current The hitobject to save to.
      */
@@ -1278,12 +1281,15 @@ declare class DroidVisual extends DroidSkill {
     protected readonly starsPerDouble: number;
     protected readonly reducedSectionCount: number;
     protected readonly reducedSectionBaseline: number;
-    protected readonly skillMultiplier: number;
     protected readonly strainDecayBase: number;
     private readonly isHidden;
-    private readonly withsliders;
+    private readonly withSliders;
+    private currentVisualStrain;
+    private currentRhythmMultiplier;
+    private readonly skillMultiplier;
     constructor(mods: Mod[], withSliders: boolean);
     protected strainValueAt(current: DifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
     protected saveToHitObject(current: DifficultyHitObject): void;
 }
 
@@ -1431,18 +1437,16 @@ declare class MapStars {
  * Represents the skill required to correctly aim at every object in the map with a uniform CircleSize and normalized distances.
  */
 declare class OsuAim extends OsuSkill {
-    protected readonly skillMultiplier: number;
     protected readonly strainDecayBase: number;
     protected readonly reducedSectionCount: number;
     protected readonly reducedSectionBaseline: number;
-    protected readonly difficultyMultiplier: number;
     protected readonly decayWeight: number;
+    private currentAimStrain;
+    private readonly skillMultiplier;
     private readonly withSliders;
     constructor(mods: Mod[], withSliders: boolean);
-    /**
-     * @param current The hitobject to calculate.
-     */
     protected strainValueAt(current: DifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
     /**
      * @param current The hitobject to save to.
      */
@@ -1471,17 +1475,16 @@ declare abstract class OsuAimEvaluator extends AimEvaluator {
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 declare class OsuFlashlight extends OsuSkill {
-    protected readonly skillMultiplier: number;
     protected readonly strainDecayBase: number;
     protected readonly reducedSectionCount: number;
     protected readonly reducedSectionBaseline: number;
     protected readonly decayWeight: number;
+    private currentFlashlightStrain;
+    private readonly skillMultiplier;
     private readonly isHidden;
     constructor(mods: Mod[]);
-    /**
-     * @param current The hitobject to calculate.
-     */
     protected strainValueAt(current: DifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
     protected saveToHitObject(current: DifficultyHitObject): void;
 }
 
@@ -1527,12 +1530,12 @@ declare class OsuPerformanceCalculator extends PerformanceCalculator {
     readonly difficultyAttributes: OsuDifficultyAttributes;
     protected finalMultiplier: number;
     protected readonly mode: Modes;
+    protected calculateValues(): void;
+    protected calculateTotalValue(): number;
     /**
      * @param difficultyAttributes The difficulty attributes to calculate.
      */
     constructor(difficultyAttributes: OsuDifficultyAttributes);
-    protected calculateValues(): void;
-    protected calculateTotalValue(): void;
     /**
      * Calculates the aim performance value of the beatmap.
      */
@@ -1570,7 +1573,6 @@ declare abstract class OsuRhythmEvaluator extends RhythmEvaluator {
  * Represents the skill required to press keys or tap with regards to keeping up with the speed at which objects need to be hit.
  */
 declare class OsuSpeed extends OsuSkill {
-    protected readonly skillMultiplier: number;
     protected readonly strainDecayBase: number;
     protected readonly reducedSectionCount: number;
     protected readonly reducedSectionBaseline: number;
@@ -1578,12 +1580,14 @@ declare class OsuSpeed extends OsuSkill {
     protected readonly decayWeight: number;
     private currentSpeedStrain;
     private currentRhythm;
+    private readonly skillMultiplier;
     private readonly greatWindow;
     constructor(mods: Mod[], greatWindow: number);
     /**
      * @param current The hitobject to calculate.
      */
     protected strainValueAt(current: DifficultyHitObject): number;
+    protected calculateInitialStrain(time: number, current: DifficultyHitObject): number;
     /**
      * @param current The hitobject to save to.
      */
@@ -1611,4 +1615,4 @@ declare abstract class OsuSpeedEvaluator extends SpeedEvaluator {
     static evaluateDifficultyOf(current: DifficultyHitObject, greatWindow: number): number;
 }
 
-export { AimEvaluator, CalculationOptions, DifficultSlider, DifficultyAttributes, DifficultyCalculationOptions, DifficultyCalculator, DifficultyHitObject, DifficultyHitObjectCreator, DroidAim, DroidAimEvaluator, DroidDifficultyAttributes, DroidDifficultyCalculator, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, ExtendedDroidDifficultyAttributes, FlashlightEvaluator, HighStrainSection, MapStars, OsuAim, OsuAimEvaluator, OsuDifficultyAttributes, OsuDifficultyCalculator, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, PerformanceCalculationOptions, PerformanceCalculator, RhythmEvaluator, SpeedEvaluator, StrainPeaks };
+export { AimEvaluator, type CalculationOptions, type DifficultSlider, type DifficultyAttributes, type DifficultyCalculationOptions, DifficultyCalculator, DifficultyHitObject, DifficultyHitObjectCreator, DroidAim, DroidAimEvaluator, type DroidDifficultyAttributes, DroidDifficultyCalculator, DroidFlashlight, DroidFlashlightEvaluator, DroidPerformanceCalculator, DroidRhythm, DroidRhythmEvaluator, DroidTap, DroidTapEvaluator, DroidVisual, DroidVisualEvaluator, type ExtendedDroidDifficultyAttributes, FlashlightEvaluator, type HighStrainSection, MapStars, OsuAim, OsuAimEvaluator, type OsuDifficultyAttributes, OsuDifficultyCalculator, OsuFlashlight, OsuFlashlightEvaluator, OsuPerformanceCalculator, OsuRhythmEvaluator, OsuSpeed, OsuSpeedEvaluator, type PerformanceCalculationOptions, PerformanceCalculator, RhythmEvaluator, SpeedEvaluator, type StrainPeaks };