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

package/dist/index.js

@@ -287,10 +287,10 @@ 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, isHidden) {
+    opacityAt(time, mods) {
         if (time > this.object.startTime) {
             // Consider a hitobject as being invisible when its start time is passed.
             // In reality the hitobject will be visible beyond its start time up until its hittable window has passed,
@@ -299,7 +299,7 @@ class DifficultyHitObject {
         }
         const fadeInStartTime = this.object.startTime - this.object.timePreempt;
         const fadeInDuration = this.object.timeFadeIn;
-        if (isHidden) {
+        if (mods.some((m) => m instanceof osuBase.ModHidden)) {
             const fadeOutStartTime = fadeInStartTime + fadeInDuration;
             const fadeOutDuration = this.object.timePreempt * osuBase.ModHidden.fadeOutDurationMultiplier;
             return Math.min(osuBase.MathUtils.clamp((time - fadeInStartTime) / fadeInDuration, 0, 1), 1 -
@@ -582,6 +582,14 @@ class DroidDifficultyHitObject extends DifficultyHitObject {
         super.computeProperties(clockRate, hitObjects);
         this.setVisuals(clockRate, hitObjects);
     }
+    opacityAt(time, mods) {
+        // Traceable hides the primary piece of a hit circle (that is, its body), so consider it as fully invisible.
+        if (this.object instanceof osuBase.Circle &&
+            mods.some((m) => m instanceof osuBase.ModTraceable)) {
+            return 0;
+        }
+        return super.opacityAt(time, mods);
+    }
     /**
      * Determines whether this hitobject is considered overlapping with the hitobject before it.
      *
@@ -1219,10 +1227,10 @@ class DroidFlashlightEvaluator {
      * - 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, isHiddenMod, withSliders) {
+    static evaluateDifficultyOf(current, mods, withSliders) {
         if (current.object instanceof osuBase.Spinner ||
             // Exclude overlapping objects that can be tapped at once.
             current.isOverlapping(true)) {
@@ -1253,7 +1261,7 @@ class DroidFlashlightEvaluator {
                 const opacityBonus = 1 +
                     this.maxOpacityBonus *
                         (1 -
-                            current.opacityAt(currentObject.object.startTime, isHiddenMod));
+                            current.opacityAt(currentObject.object.startTime, mods));
                 result +=
                     (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
                         cumulativeStrainTime;
@@ -1268,9 +1276,20 @@ class DroidFlashlightEvaluator {
         }
         result = Math.pow(smallDistNerf * result, 2);
         // Additional bonus for Hidden due to there being no approach circles.
-        if (isHiddenMod) {
+        if (mods.some((m) => m instanceof osuBase.ModHidden)) {
             result *= 1 + this.hiddenBonus;
         }
+        else if (mods.some((m) => m instanceof osuBase.ModTraceable)) {
+            // Additional bonus for Traceable due to there being no primary or secondary object pieces.
+            if (current.object instanceof osuBase.Circle) {
+                // Additional bonus for hit circles due to there being no circle piece, which is the primary piece.
+                result *= 1 + this.traceableCircleBonus;
+            }
+            else {
+                // The rest of the objects only hide secondary pieces.
+                result *= 1 + this.traceableObjectBonus;
+            }
+        }
         // Nerf patterns with repeated angles.
         result *=
             this.minAngleMultiplier +
@@ -1293,6 +1312,8 @@ class DroidFlashlightEvaluator {
 }
 DroidFlashlightEvaluator.maxOpacityBonus = 0.4;
 DroidFlashlightEvaluator.hiddenBonus = 0.2;
+DroidFlashlightEvaluator.traceableCircleBonus = 0.15;
+DroidFlashlightEvaluator.traceableObjectBonus = 0.1;
 DroidFlashlightEvaluator.minVelocity = 0.5;
 DroidFlashlightEvaluator.sliderMultiplier = 1.3;
 DroidFlashlightEvaluator.minAngleMultiplier = 0.2;
@@ -1309,13 +1330,12 @@ class DroidFlashlight extends DroidSkill {
         this.starsPerDouble = 1.06;
         this.skillMultiplier = 0.02;
         this.currentFlashlightStrain = 0;
-        this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
         this.withSliders = withSliders;
     }
     strainValueAt(current) {
         this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
         this.currentFlashlightStrain +=
-            DroidFlashlightEvaluator.evaluateDifficultyOf(current, this.isHidden, this.withSliders) * this.skillMultiplier;
+            DroidFlashlightEvaluator.evaluateDifficultyOf(current, this.mods, this.withSliders) * this.skillMultiplier;
         return this.currentFlashlightStrain;
     }
     calculateInitialStrain(time, current) {
@@ -1582,22 +1602,31 @@ 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, isHiddenMod, withSliders) {
+    static evaluateDifficultyOf(current, mods, withSliders) {
         if (current.object instanceof osuBase.Spinner ||
             // Exclude overlapping objects that can be tapped at once.
             current.isOverlapping(true) ||
             current.index === 0) {
             return 0;
         }
-        // Start with base density and give global bonus for Hidden.
+        // Start with base density and give global bonus for Hidden and Traceable.
         // Add density caps for sanity.
         let strain;
-        if (isHiddenMod) {
+        if (mods.some((m) => m instanceof osuBase.ModHidden)) {
             strain = Math.min(30, Math.pow(current.noteDensity, 3));
         }
+        else if (mods.some((m) => m instanceof osuBase.ModTraceable)) {
+            // Give more bonus for hit circles due to there being no circle piece.
+            if (current.object instanceof osuBase.Circle) {
+                strain = Math.min(25, Math.pow(current.noteDensity, 2.5));
+            }
+            else {
+                strain = Math.min(22.5, Math.pow(current.noteDensity, 2.25));
+            }
+        }
         else {
             strain = Math.min(20, Math.pow(current.noteDensity, 2));
         }
@@ -1615,9 +1644,7 @@ class DroidVisualEvaluator {
                 break;
             }
             strain +=
-                (1 -
-                    current.opacityAt(previous.object.startTime, isHiddenMod)) /
-                    4;
+                (1 - current.opacityAt(previous.object.startTime, mods)) / 4;
         }
         if (current.timePreempt < 400) {
             // Give bonus for AR higher than 10.33.
@@ -1677,13 +1704,12 @@ class DroidVisual extends DroidSkill {
         this.currentVisualStrain = 0;
         this.currentRhythmMultiplier = 1;
         this.skillMultiplier = 10;
-        this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
         this.withSliders = withSliders;
     }
     strainValueAt(current) {
         this.currentVisualStrain *= this.strainDecay(current.deltaTime);
         this.currentVisualStrain +=
-            DroidVisualEvaluator.evaluateDifficultyOf(current, this.isHidden, this.withSliders) * this.skillMultiplier;
+            DroidVisualEvaluator.evaluateDifficultyOf(current, this.mods, this.withSliders) * this.skillMultiplier;
         this.currentRhythmMultiplier = current.rhythmMultiplier;
         return this.currentVisualStrain * this.currentRhythmMultiplier;
     }
@@ -3377,9 +3403,9 @@ class OsuFlashlightEvaluator {
      * - 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, isHiddenMod) {
+    static evaluateDifficultyOf(current, mods) {
         if (current.object instanceof osuBase.Spinner) {
             return 0;
         }
@@ -3406,7 +3432,7 @@ class OsuFlashlightEvaluator {
                 const opacityBonus = 1 +
                     this.maxOpacityBonus *
                         (1 -
-                            current.opacityAt(currentObject.object.startTime, isHiddenMod));
+                            current.opacityAt(currentObject.object.startTime, mods));
                 result +=
                     (stackNerf * opacityBonus * scalingFactor * jumpDistance) /
                         cumulativeStrainTime;
@@ -3421,7 +3447,7 @@ class OsuFlashlightEvaluator {
         }
         result = Math.pow(smallDistNerf * result, 2);
         // Additional bonus for Hidden due to there being no approach circles.
-        if (isHiddenMod) {
+        if (mods.some((m) => m instanceof osuBase.ModHidden)) {
             result *= 1 + this.hiddenBonus;
         }
         // Nerf patterns with repeated angles.
@@ -3454,15 +3480,14 @@ OsuFlashlightEvaluator.minAngleMultiplier = 0.2;
  * Represents the skill required to memorize and hit every object in a beatmap with the Flashlight mod enabled.
  */
 class OsuFlashlight extends OsuSkill {
-    constructor(mods) {
-        super(mods);
+    constructor() {
+        super(...arguments);
         this.strainDecayBase = 0.15;
         this.reducedSectionCount = 0;
         this.reducedSectionBaseline = 1;
         this.decayWeight = 1;
         this.currentFlashlightStrain = 0;
         this.skillMultiplier = 0.05512;
-        this.isHidden = mods.some((m) => m instanceof osuBase.ModHidden);
     }
     difficultyValue() {
         return this.strainPeaks.reduce((a, b) => a + b, 0);
@@ -3470,7 +3495,8 @@ class OsuFlashlight extends OsuSkill {
     strainValueAt(current) {
         this.currentFlashlightStrain *= this.strainDecay(current.deltaTime);
         this.currentFlashlightStrain +=
-            OsuFlashlightEvaluator.evaluateDifficultyOf(current, this.isHidden) * this.skillMultiplier;
+            OsuFlashlightEvaluator.evaluateDifficultyOf(current, this.mods) *
+                this.skillMultiplier;
         return this.currentFlashlightStrain;
     }
     calculateInitialStrain(time, current) {
@@ -3805,7 +3831,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             aimValue *= 1 + arFactor * lengthBonus;
         }
         // We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
-        if (this.mods.some((m) => m instanceof osuBase.ModHidden)) {
+        if (this.mods.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModTraceable)) {
             aimValue *= 1 + 0.04 * (12 - calculatedAR);
         }
         // Scale the aim value with slider factor to nerf very likely dropped sliderends.
@@ -3840,7 +3866,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             // Buff for longer maps with high AR.
             speedValue *= 1 + 0.3 * (calculatedAR - 10.33) * lengthBonus;
         }
-        if (this.mods.some((m) => m instanceof osuBase.ModHidden)) {
+        if (this.mods.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModTraceable)) {
             speedValue *= 1 + 0.04 * (12 - calculatedAR);
         }
         // Calculate accuracy assuming the worst case scenario.
@@ -3890,7 +3916,7 @@ class OsuPerformanceCalculator extends PerformanceCalculator {
             2.83;
         // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
         accuracyValue *= Math.min(1.15, Math.pow(ncircles / 1000, 0.3));
-        if (this.mods.some((m) => m instanceof osuBase.ModHidden)) {
+        if (this.mods.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModTraceable)) {
             accuracyValue *= 1.08;
         }
         if (this.mods.some((m) => m instanceof osuBase.ModFlashlight)) {

package/package.json

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

package/typings/index.d.ts

@@ -242,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.
@@ -610,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.
      *
@@ -913,7 +914,6 @@ declare class DroidFlashlight extends DroidSkill {
     protected readonly reducedSectionBaseline = 1;
     protected readonly starsPerDouble = 1.06;
     private readonly skillMultiplier;
-    private readonly isHidden;
     private currentFlashlightStrain;
     readonly withSliders: boolean;
     constructor(mods: Mod[], withSliders: boolean);
@@ -930,6 +930,8 @@ declare class DroidFlashlight extends DroidSkill {
 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;
@@ -943,10 +945,10 @@ declare abstract class DroidFlashlightEvaluator {
      * - 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;
 }
 
 /**
@@ -1347,7 +1349,6 @@ declare class DroidVisual extends DroidSkill {
     protected readonly reducedSectionCount = 10;
     protected readonly reducedSectionBaseline = 0.75;
     protected readonly strainDecayBase = 0.1;
-    private readonly isHidden;
     private currentVisualStrain;
     private currentRhythmMultiplier;
     private readonly skillMultiplier;
@@ -1375,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;
 }
 
 /**
@@ -1549,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;
@@ -1576,9 +1575,9 @@ declare abstract class OsuFlashlightEvaluator {
      * - 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;
 }
 
 /**