Merge branch 'master' into beatmap-listing-enum-localisation

osu.Game.Rulesets.Taiko.Tests/Mods/TaikoModTestScene.cs

@@ -0,0 +1,12 @@
+// 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.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Mods
+{
+    public abstract class TaikoModTestScene : ModTestScene
+    {
+        protected sealed override Ruleset CreatePlayerRuleset() => new TaikoRuleset();
+    }
+}

osu.Game.Rulesets.Taiko.Tests/Mods/TestSceneTaikoModHidden.cs

@@ -0,0 +1,24 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Game.Rulesets.Taiko.Mods;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Mods
+{
+    public class TestSceneTaikoModHidden : TaikoModTestScene
+    {
+        [Test]
+        public void TestDefaultBeatmapTest() => CreateModTest(new ModTestData
+        {
+            Mod = new TaikoModHidden(),
+            Autoplay = true,
+            PassCondition = checkSomeAutoplayHits
+        });
+
+        private bool checkSomeAutoplayHits()
+            => Player.ScoreProcessor.JudgedHits >= 4
+               && Player.Results.All(result => result.Type == result.Judgement.MaxResult);
+    }
+}

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

@@ -1,23 +1,93 @@
 // 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.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Taiko.Mods
 {
-    public class TaikoModHidden : ModHidden
+    public class TaikoModHidden : ModHidden, IApplicableToDifficulty
     {
         public override string Description => @"Beats fade out before you hit them!";
         public override double ScoreMultiplier => 1.06;
-        public override bool HasImplementation => false;
+
+        /// <summary>
+        /// In osu-stable, the hit position is 160, so the active playfield is essentially 160 pixels shorter
+        /// than the actual screen width. The normalized playfield height is 480, so on a 4:3 screen the
+        /// playfield ratio of the active area up to the hit position will actually be (640 - 160) / 480 = 1.
+        /// For custom resolutions/aspect ratios (x:y), the screen width given the normalized height becomes 480 * x / y instead,
+        /// and the playfield ratio becomes (480 * x / y - 160) / 480 = x / y - 1/3.
+        /// This constant is equal to the playfield ratio on 4:3 screens divided by the playfield ratio on 16:9 screens.
+        /// </summary>
+        private const double hd_sv_scale = (4.0 / 3.0 - 1.0 / 3.0) / (16.0 / 9.0 - 1.0 / 3.0);
+
+        private double originalSliderMultiplier;
+
+        private ControlPointInfo controlPointInfo;
 
         protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
+            ApplyNormalVisibilityState(hitObject, state);
+        }
+
+        protected double MultiplierAt(double position)
+        {
+            double beatLength = controlPointInfo.TimingPointAt(position).BeatLength;
+            double speedMultiplier = controlPointInfo.DifficultyPointAt(position).SpeedMultiplier;
+
+            return originalSliderMultiplier * speedMultiplier * TimingControlPoint.DEFAULT_BEAT_LENGTH / beatLength;
         }
 
         protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
+            switch (hitObject)
+            {
+                case DrawableDrumRollTick _:
+                case DrawableHit _:
+                    double preempt = 10000 / MultiplierAt(hitObject.HitObject.StartTime);
+                    double start = hitObject.HitObject.StartTime - preempt * 0.6;
+                    double duration = preempt * 0.3;
+
+                    using (hitObject.BeginAbsoluteSequence(start))
+                    {
+                        hitObject.FadeOut(duration);
+
+                        // DrawableHitObject sets LifetimeEnd to LatestTransformEndTime if it isn't manually changed.
+                        // in order for the object to not be killed before its actual end time (as the latest transform ends earlier), set lifetime end explicitly.
+                        hitObject.LifetimeEnd = state == ArmedState.Idle || !hitObject.AllJudged
+                            ? hitObject.HitObject.GetEndTime() + hitObject.HitObject.HitWindows.WindowFor(HitResult.Miss)
+                            : hitObject.HitStateUpdateTime;
+                    }
+
+                    break;
+            }
+        }
+
+        public void ReadFromDifficulty(BeatmapDifficulty difficulty)
+        {
+        }
+
+        public void ApplyToDifficulty(BeatmapDifficulty difficulty)
+        {
+            // needs to be read after all processing has been run (TaikoBeatmapConverter applies an adjustment which would otherwise be omitted).
+            originalSliderMultiplier = difficulty.SliderMultiplier;
+
+            // osu-stable has an added playfield cover that essentially forces a 4:3 playfield ratio, by cutting off all objects past that size.
+            // This is not yet implemented; instead a playfield adjustment container is present which maintains a 16:9 ratio.
+            // For now, increase the slider multiplier proportionally so that the notes stay on the screen for the same amount of time as on stable.
+            // Note that this means that the notes will scroll faster as they have a longer distance to travel on the screen in that same amount of time.
+            difficulty.SliderMultiplier /= hd_sv_scale;
+        }
+
+        public override void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            controlPointInfo = beatmap.ControlPointInfo;
         }
     }
 }

osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using JetBrains.Annotations;
 using Newtonsoft.Json;
 using osu.Framework.Bindables;
 using osu.Framework.Lists;
@@ -66,6 +67,7 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         /// <param name="time">The time to find the difficulty control point at.</param>
         /// <returns>The difficulty control point.</returns>
+        [NotNull]
         public DifficultyControlPoint DifficultyPointAt(double time) => binarySearchWithFallback(DifficultyPoints, time, DifficultyControlPoint.DEFAULT);
 
         /// <summary>
@@ -73,6 +75,7 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         /// <param name="time">The time to find the effect control point at.</param>
         /// <returns>The effect control point.</returns>
+        [NotNull]
         public EffectControlPoint EffectPointAt(double time) => binarySearchWithFallback(EffectPoints, time, EffectControlPoint.DEFAULT);
 
         /// <summary>
@@ -80,6 +83,7 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         /// <param name="time">The time to find the sound control point at.</param>
         /// <returns>The sound control point.</returns>
+        [NotNull]
         public SampleControlPoint SamplePointAt(double time) => binarySearchWithFallback(SamplePoints, time, SamplePoints.Count > 0 ? SamplePoints[0] : SampleControlPoint.DEFAULT);
 
         /// <summary>
@@ -87,6 +91,7 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         /// <param name="time">The time to find the timing control point at.</param>
         /// <returns>The timing control point.</returns>
+        [NotNull]
         public TimingControlPoint TimingPointAt(double time) => binarySearchWithFallback(TimingPoints, time, TimingPoints.Count > 0 ? TimingPoints[0] : TimingControlPoint.DEFAULT);
 
         /// <summary>

osu.Game/OsuGame.cs

@@ -53,6 +53,7 @@ using osu.Game.Database;
 using osu.Game.Extensions;
 using osu.Game.IO;
 using osu.Game.Localisation;
+using osu.Game.Performance;
 using osu.Game.Skinning.Editor;
 
 namespace osu.Game
@@ -488,6 +489,8 @@ namespace osu.Game
 
         protected virtual UpdateManager CreateUpdateManager() => new UpdateManager();
 
+        protected virtual HighPerformanceSession CreateHighPerformanceSession() => new HighPerformanceSession();
+
         protected override Container CreateScalingContainer() => new ScalingContainer(ScalingMode.Everything);
 
         #region Beatmap progression
@@ -756,6 +759,8 @@ namespace osu.Game
             loadComponentSingleFile(new AccountCreationOverlay(), topMostOverlayContent.Add, true);
             loadComponentSingleFile(new DialogOverlay(), topMostOverlayContent.Add, true);
 
+            loadComponentSingleFile(CreateHighPerformanceSession(), Add);
+
             chatOverlay.State.ValueChanged += state => channelManager.HighPollRate.Value = state.NewValue == Visibility.Visible;
 
             Add(difficultyRecommender);

osu.Game/Performance/HighPerformanceSession.cs

@@ -0,0 +1,47 @@
+// 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.Runtime;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+
+namespace osu.Game.Performance
+{
+    public class HighPerformanceSession : Component
+    {
+        private readonly IBindable<bool> localUserPlaying = new Bindable<bool>();
+        private GCLatencyMode originalGCMode;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuGame game)
+        {
+            localUserPlaying.BindTo(game.LocalUserPlaying);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            localUserPlaying.BindValueChanged(playing =>
+            {
+                if (playing.NewValue)
+                    EnableHighPerformanceSession();
+                else
+                    DisableHighPerformanceSession();
+            }, true);
+        }
+
+        protected virtual void EnableHighPerformanceSession()
+        {
+            originalGCMode = GCSettings.LatencyMode;
+            GCSettings.LatencyMode = GCLatencyMode.LowLatency;
+        }
+
+        protected virtual void DisableHighPerformanceSession()
+        {
+            if (GCSettings.LatencyMode == GCLatencyMode.LowLatency)
+                GCSettings.LatencyMode = originalGCMode;
+        }
+    }
+}

osu.Game/Skinning/SkinnableTargetContainer.cs

@@ -18,6 +18,8 @@ namespace osu.Game.Skinning
 
         private readonly BindableList<ISkinnableDrawable> components = new BindableList<ISkinnableDrawable>();
 
+        public bool ComponentsLoaded { get; private set; }
+
         public SkinnableTargetContainer(SkinnableTarget target)
         {
             Target = target;
@@ -30,6 +32,7 @@ namespace osu.Game.Skinning
         {
             ClearInternal();
             components.Clear();
+            ComponentsLoaded = false;
 
             content = CurrentSkin.GetDrawableComponent(new SkinnableTargetComponent(Target)) as SkinnableTargetComponentsContainer;
 
@@ -39,8 +42,11 @@ namespace osu.Game.Skinning
                 {
                     AddInternal(wrapper);
                     components.AddRange(wrapper.Children.OfType<ISkinnableDrawable>());
+                    ComponentsLoaded = true;
                 });
             }
+            else
+                ComponentsLoaded = true;
         }
 
         /// <inheritdoc cref="ISkinnableTarget"/>

osu.Game/Tests/Visual/LegacySkinPlayerTestScene.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 System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
@@ -47,6 +48,8 @@ namespace osu.Game.Tests.Visual
                 LegacySkin.ResetDrawableTarget(t);
                 t.Reload();
             }));
+
+            AddUntilStep("wait for components to load", () => this.ChildrenOfType<SkinnableTargetContainer>().All(t => t.ComponentsLoaded));
         }
 
         public class SkinProvidingPlayer : TestPlayer