Classic hidden

osu.Game.Rulesets.Taiko/Mods/TaikoModClassic.cs

@@ -1,6 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Objects;
@@ -12,18 +17,61 @@ namespace osu.Game.Rulesets.Taiko.Mods
 {
     public class TaikoModClassic : ModClassic, IApplicableToDrawableRuleset<TaikoHitObject>, IApplicableToDrawableHitObject
     {
+        private IReadOnlyList<Mod> mods = Array.Empty<Mod>();
+
+        private const float default_hidden_fade_out_duration = 0.375f;
+
+        private const float default_hidden_initial_alpha = 0.75f;
+
+        private const float hidden_base_aspect = 4f / 3f;
+
+        private readonly BindableFloat hiddenFadeOutDuration = new BindableFloat(default_hidden_fade_out_duration);
+
+        private readonly BindableFloat hiddenInitialAlpha = new BindableFloat(default_hidden_initial_alpha);
+
+
         public void ApplyToDrawableRuleset(DrawableRuleset<TaikoHitObject> drawableRuleset)
         {
             var drawableTaikoRuleset = (DrawableTaikoRuleset)drawableRuleset;
+
+            // drawableRuleset.Mods should always be non-null here, but just in case.
+            mods = drawableRuleset.Mods ?? mods;
+
             drawableTaikoRuleset.MaximumAspect.Value = 22f / 9f;
             drawableTaikoRuleset.MinimumAspect.Value = 5f / 4f;
             drawableTaikoRuleset.TrimOnOverflow.Value = true;
+
+            TaikoModHidden? hidden = mods.OfType<TaikoModHidden>().FirstOrDefault();
+            if (hidden != null)
+            {
+                // Stable limits the aspect ratio to 4:3
+                drawableTaikoRuleset.MaximumAspect.Value = hidden_base_aspect;
+
+                // Enable aspect ratio adjustment for hidden (see adjustHidden)
+                hiddenInitialAlpha.BindTo(hidden.InitialAlpha);
+                hiddenFadeOutDuration.BindTo(hidden.FadeOutDuration);
+                drawableRuleset.OnUpdate += adjustHidden;
+            }
         }
 
         public void ApplyToDrawableHitObject(DrawableHitObject drawable)
         {
             if (drawable is DrawableTaikoHitObject hit)
                 hit.SnapJudgementLocation = true;
         }
+
+        // Compensate for aspect ratios narrower than 4:3 by scaling the fade out duration and initial alpha
+        private void adjustHidden(Drawable drawableRuleset)
+        {
+            var drawableTaikoRuleset = (DrawableTaikoRuleset)drawableRuleset;
+
+            if (drawableTaikoRuleset.CurrentAspect.Value < hidden_base_aspect)
+            {
+                hiddenFadeOutDuration.Value =
+                    default_hidden_fade_out_duration * (drawableTaikoRuleset.CurrentAspect.Value / hidden_base_aspect);
+                hiddenInitialAlpha.Value =
+                    default_hidden_initial_alpha * (drawableTaikoRuleset.CurrentAspect.Value / hidden_base_aspect);
+            }
+        }
     }
 }

osu.Game.Rulesets.Taiko/Mods/TaikoModHidden.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Localisation;
 using osu.Game.Rulesets.Mods;
@@ -29,7 +30,20 @@ public class TaikoModHidden : ModHidden, IApplicableToDrawableRuleset<TaikoHitOb
         /// How long hitobjects take to fade out, in terms of the scrolling length.
         /// Range: [0, 1]
         /// </summary>
-        private const float fade_out_duration = 0.375f;
+        public readonly BindableFloat FadeOutDuration = new BindableFloat(0.375f)
+        {
+            MinValue = 0f,
+            MaxValue = 1f
+        };
+
+        /// <summary>
+        /// The initial alpha of hitobjects when they appear.
+        /// </summary>
+        public readonly BindableFloat InitialAlpha = new BindableFloat(1f)
+        {
+            MinValue = 0f,
+            MaxValue = 1f
+        };
 
         private DrawableTaikoRuleset drawableRuleset = null!;
 
@@ -51,7 +65,8 @@ protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject,
                 case DrawableHit:
                     double preempt = drawableRuleset.TimeRange.Value / drawableRuleset.ControlPointAt(hitObject.HitObject.StartTime).Multiplier;
                     double start = hitObject.HitObject.StartTime - preempt * fade_out_start_time;
-                    double duration = preempt * fade_out_duration;
+                    double duration = preempt * FadeOutDuration.Value;
+                    hitObject.Alpha = InitialAlpha.Value;
 
                     using (hitObject.BeginAbsoluteSequence(start))
                     {

osu.Game.Rulesets.Taiko/UI/DrawableTaikoRuleset.cs

@@ -37,6 +37,8 @@ public partial class DrawableTaikoRuleset : DrawableScrollingRuleset<TaikoHitObj
 
         public readonly BindableBool TrimOnOverflow = new BindableBool(false);
 
+        public readonly BindableFloat CurrentAspect = new BindableFloat(16f / 9f);
+
         public new TaikoInputManager KeyBindingInputManager => (TaikoInputManager)base.KeyBindingInputManager;
 
         protected new TaikoPlayfieldAdjustmentContainer PlayfieldAdjustmentContainer => (TaikoPlayfieldAdjustmentContainer)base.PlayfieldAdjustmentContainer;
@@ -95,7 +97,8 @@ public MultiplierControlPoint ControlPointAt(double time)
         {
             MaximumAspect = { BindTarget = MaximumAspect },
             MinimumAspect = { BindTarget = MinimumAspect },
-            TrimOnOverflow = { BindTarget = TrimOnOverflow }
+            TrimOnOverflow = { BindTarget = TrimOnOverflow },
+            CurrentAspect = { BindTarget = CurrentAspect }
         };
 
         protected override PassThroughInputManager CreateInputManager() => new TaikoInputManager(Ruleset.RulesetInfo);

osu.Game.Rulesets.Taiko/UI/TaikoPlayfieldAdjustmentContainer.cs

@@ -18,6 +18,8 @@ public partial class TaikoPlayfieldAdjustmentContainer : PlayfieldAdjustmentCont
 
         public BindableFloat MinimumAspect = new BindableFloat(5f / 4f);
 
+        public BindableFloat CurrentAspect = new BindableFloat(16f / 9f);
+
         public BindableBool TrimOnOverflow = new BindableBool(false);
 
         public TaikoPlayfieldAdjustmentContainer()
@@ -45,22 +47,22 @@ protected override void Update()
             //
             // As a middle-ground, the aspect ratio can still be adjusted in the downwards direction but has a maximum limit.
             // This is still a bit weird, because readability changes with window size, but it is what it is.
-            float currentAspect = Parent!.ChildSize.X / Parent!.ChildSize.Y;
+            CurrentAspect.Value = Parent!.ChildSize.X / Parent!.ChildSize.Y;
 
-            if (currentAspect > MaximumAspect.Value)
+            if (CurrentAspect.Value > MaximumAspect.Value)
             {
                 if (TrimOnOverflow.Value)
                 {
-                    widthScale = MaximumAspect.Value / currentAspect;
+                    widthScale = MaximumAspect.Value / CurrentAspect.Value;
                 }
                 else
                 {
-                    relativeHeight *= currentAspect / MaximumAspect.Value;
+                    relativeHeight *= CurrentAspect.Value / MaximumAspect.Value;
                 }
             }
-            else if (currentAspect < MinimumAspect.Value)
+            else if (CurrentAspect.Value < MinimumAspect.Value)
             {
-                relativeHeight *= currentAspect / MinimumAspect.Value;
+                relativeHeight *= CurrentAspect.Value / MinimumAspect.Value;
             }