Consider opacity of hit objects in Flashlight skill

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

@@ -122,6 +122,7 @@ protected override Skill[] CreateSkills(IBeatmap beatmap, Mod[] mods, double clo
             new OsuModEasy(),
             new OsuModHardRock(),
             new OsuModFlashlight(),
+            new MultiMod(new OsuModFlashlight(), new OsuModHidden())
         };
     }
 }

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

@@ -219,9 +219,6 @@ private double computeFlashlightValue(ScoreInfo score, OsuDifficultyAttributes a
 
             double flashlightValue = Math.Pow(rawFlashlight, 2.0) * 25.0;
 
-            if (score.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(effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));

osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs

@@ -85,6 +85,21 @@ public OsuDifficultyHitObject(HitObject hitObject, HitObject lastLastObject, Hit
             setDistances(clockRate);
         }
 
+        public double Opacity(double mapTime, bool hidden)
+        {
+            double ms = BaseObject.StartTime - mapTime;
+            if (ms < 0)
+                return 0.0;
+
+            double preemptTime = BaseObject.TimePreempt;
+            double fadeInTime = BaseObject.TimeFadeIn;
+
+            if (hidden)
+                return Math.Clamp(Math.Min((1.0 - ms / preemptTime) * 2.5, (ms / preemptTime - 0.3) * (1.0 / 0.3)), 0.0, 1.0);
+            else
+                return Math.Clamp((preemptTime - ms) / fadeInTime, 0.0, 1.0);
+        }
+
         private void setDistances(double clockRate)
         {
             if (BaseObject is Slider currentSlider)

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;
 
@@ -17,13 +19,19 @@ public class Flashlight : OsuStrainSkill
         public Flashlight(Mod[] mods)
             : base(mods)
         {
+            hidden = mods.Any(m => m is OsuModHidden);
         }
 
-        private double skillMultiplier => 0.07;
+        private double skillMultiplier => 0.05;
         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 bool hidden;
+
+        private const double max_opacity_bonus = 0.4;
+        private const double hidden_bonus = 0.2;
+
         private double currentStrain;
 
         private double strainValueOf(DifficultyHitObject current)
@@ -61,13 +69,22 @@ 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, (currentObj.LazyJumpDistance / scalingFactor) / 25.0);
 
-                    result += stackNerf * scalingFactor * jumpDistance / cumulativeStrainTime;
+                    // Bonus based on how visible the object is.
+                    double opacityBonus = 1.0 + max_opacity_bonus * (1.0 - osuCurrent.Opacity(currentHitObject.StartTime, hidden));
+
+                    result += stackNerf * opacityBonus * scalingFactor * jumpDistance / cumulativeStrainTime;
                 }
 
                 lastObj = currentObj;
             }
 
-            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 strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);