Consider opacity of hit objects in Flashlight skill

osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs

@@ -22,6 +22,7 @@ public class OsuDifficultyCalculator : DifficultyCalculator
     {
         private const double difficulty_multiplier = 0.0675;
         private double hitWindowGreat;
+        private double preempt;
 
         public OsuDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
@@ -59,7 +60,6 @@ protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beat
 
             double starRating = basePerformance > 0.00001 ? Math.Cbrt(1.12) * 0.027 * (Math.Cbrt(100000 / Math.Pow(2, 1 / 1.1) * basePerformance) + 4) : 0;
 
-            double preempt = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
             double drainRate = beatmap.Difficulty.DrainRate;
 
             int maxCombo = beatmap.HitObjects.Count;
@@ -110,12 +110,14 @@ protected override Skill[] CreateSkills(IBeatmap beatmap, Mod[] mods, double clo
 
             hitWindowGreat = hitWindows.WindowFor(HitResult.Great) / clockRate;
 
+            preempt = IBeatmapDifficultyInfo.DifficultyRange(beatmap.Difficulty.ApproachRate, 1800, 1200, 450) / clockRate;
+
             return new Skill[]
             {
                 new Aim(mods, true),
                 new Aim(mods, false),
                 new Speed(mods, hitWindowGreat),
-                new Flashlight(mods)
+                new Flashlight(mods, preempt)
             };
         }
 
@@ -126,6 +128,7 @@ protected override Skill[] CreateSkills(IBeatmap beatmap, Mod[] mods, double clo
             new OsuModEasy(),
             new OsuModHardRock(),
             new OsuModFlashlight(),
+            new OsuModHidden()
         };
     }
-}
+}

osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs

@@ -234,10 +234,6 @@ private double computeFlashlightValue()
 
             double flashlightValue = Math.Pow(rawFlashlight, 2.0) * 25.0;
 
-            // Add an additional bonus for HDFL.
-            if (mods.Any(h => h is OsuModHidden))
-                flashlightValue *= 1.3;
-
             // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
             if (effectiveMissCount > 0)
                 flashlightValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));

osu.Game.Rulesets.Osu/Difficulty/Skills/Flashlight.cs

@@ -2,8 +2,10 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Linq;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Osu.Objects;
 
@@ -14,23 +16,34 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
     /// </summary>
     public class Flashlight : OsuStrainSkill
     {
-        public Flashlight(Mod[] mods)
+        public Flashlight(Mod[] mods, double preemptTime)
             : base(mods)
         {
+            this.mods = mods;
+            this.preemptTime = preemptTime;
         }
 
-        private double skillMultiplier => 0.15;
+        private double skillMultiplier => 0.09;
         private double strainDecayBase => 0.15;
         protected override double DecayWeight => 1.0;
         protected override int HistoryLength => 10; // Look back for 10 notes is added for the sake of flashlight calculations.
 
+        private readonly Mod[] mods;
+        private bool hidden;
+        private readonly double preemptTime;
+
+        private const double max_opacity_bonus = 0.7;
+        private const double hidden_bonus = 0.5;
+
         private double currentStrain;
 
         private double strainValueOf(DifficultyHitObject current)
         {
             if (current.BaseObject is Spinner)
                 return 0;
 
+            hidden = mods.Any(m => m is OsuModHidden);
+
             var osuCurrent = (OsuDifficultyHitObject)current;
             var osuHitObject = (OsuHitObject)(osuCurrent.BaseObject);
 
@@ -58,11 +71,28 @@ private double strainValueOf(DifficultyHitObject current)
                     // We also want to nerf stacks so that only the first object of the stack is accounted for.
                     double stackNerf = Math.Min(1.0, (osuPrevious.JumpDistance / scalingFactor) / 25.0);
 
-                    result += Math.Pow(0.8, i) * stackNerf * scalingFactor * jumpDistance / cumulativeStrainTime;
+                    // Bonus based on how visible the object is.
+                    double opacityBonus = 1.0 + max_opacity_bonus * (1.0 - opacity(cumulativeStrainTime, preemptTime, hidden));
+
+                    result += Math.Pow(0.8, i) * stackNerf * opacityBonus * scalingFactor * jumpDistance / cumulativeStrainTime;
                 }
             }
 
-            return Math.Pow(smallDistNerf * result, 2.0);
+            result = Math.Pow(smallDistNerf * result, 2.0);
+
+            // Additional bonus for Hidden due to there being no approach circles.
+            if (hidden)
+                result *= 1.0 + hidden_bonus;
+
+            return result;
+        }
+
+        private double opacity(double ms, double preemptTime, bool hidden)
+        {
+            if (hidden)
+                return Math.Clamp(Math.Min((1 - ms / preemptTime) * 2.5, (ms / preemptTime) * (1.0 / 0.3)), 0.0, 1.0);
+            else
+                return Math.Clamp((1.0 - ms / preemptTime) * 1.5, 0.0, 1.0);
         }
 
         private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);