Merge branch 'gcc-abstraction' into multiplayer-spectator-screen

osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs

@@ -21,6 +21,7 @@ using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
+using osu.Game.Screens.Play;
 using osu.Game.Storyboards;
 using osu.Game.Tests.Visual;
 using osuTK;
@@ -193,7 +194,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             addSeekStep(0);
 
-            AddStep("adjust track rate", () => Player.GameplayClockContainer.UserPlaybackRate.Value = rate);
+            AddStep("adjust track rate", () => ((MasterGameplayClockContainer)Player.GameplayClockContainer).UserPlaybackRate.Value = rate);
 
             addSeekStep(1000);
             AddAssert("progress almost same", () => Precision.AlmostEquals(expectedProgress, drawableSpinner.Progress, 0.05));

osu.Game.Tests/Gameplay/TestSceneGameplayClockContainer.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Tests.Gameplay
                 var working = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
                 working.LoadTrack();
 
-                Add(gcc = new GameplayClockContainer(working, 0));
+                Add(gcc = new MasterGameplayClockContainer(working, 0));
             });
 
             AddStep("start track", () => gcc.Start());

osu.Game.Tests/Gameplay/TestSceneStoryboardSamples.cs

@@ -67,7 +67,7 @@ namespace osu.Game.Tests.Gameplay
                 var working = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
                 working.LoadTrack();
 
-                Add(gameplayContainer = new GameplayClockContainer(working, 0));
+                Add(gameplayContainer = new MasterGameplayClockContainer(working, 0));
 
                 gameplayContainer.Add(sample = new DrawableStoryboardSample(new StoryboardSampleInfo(string.Empty, 0, 1))
                 {
@@ -114,7 +114,7 @@ namespace osu.Game.Tests.Gameplay
 
                 var beatmapSkinSourceContainer = new BeatmapSkinProvidingContainer(Beatmap.Value.Skin);
 
-                Add(gameplayContainer = new GameplayClockContainer(Beatmap.Value, 0)
+                Add(gameplayContainer = new MasterGameplayClockContainer(Beatmap.Value, 0)
                 {
                     Child = beatmapSkinSourceContainer
                 });

osu.Game.Tests/Visual/Gameplay/TestSceneSkipOverlay.cs

@@ -33,7 +33,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             var working = CreateWorkingBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo));
             working.LoadTrack();
 
-            Child = gameplayClockContainer = new GameplayClockContainer(working, 0)
+            Child = gameplayClockContainer = new MasterGameplayClockContainer(working, 0)
             {
                 RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]
@@ -80,7 +80,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("move mouse", () => InputManager.MoveMouseTo(skip.ScreenSpaceDrawQuad.Centre));
             AddStep("click", () =>
             {
-                increment = skip_time - gameplayClock.CurrentTime - GameplayClockContainer.MINIMUM_SKIP_TIME / 2;
+                increment = skip_time - gameplayClock.CurrentTime - MasterGameplayClockContainer.MINIMUM_SKIP_TIME / 2;
                 InputManager.Click(MouseButton.Left);
             });
             AddStep("click", () => InputManager.Click(MouseButton.Left));

osu.Game/Screens/Play/GameplayClockContainer.cs

@@ -1,200 +1,62 @@
 // 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.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Threading.Tasks;
-using osu.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Audio;
-using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Timing;
-using osu.Game.Beatmaps;
-using osu.Game.Configuration;
 
 namespace osu.Game.Screens.Play
 {
-    /// <summary>
+    public abstract class GameplayClockContainer : Container
-    /// Encapsulates gameplay timing logic and provides a <see cref="Play.GameplayClock"/> for children.
-    /// </summary>
-    public class GameplayClockContainer : Container
     {
-        private readonly WorkingBeatmap beatmap;
+        /// <summary>
-
+        /// The final clock which is exposed to underlying components.
-        [NotNull]
+        /// </summary>
-        private ITrack track;
+        public GameplayClock GameplayClock { get; private set; }
 
         public readonly BindableBool IsPaused = new BindableBool();
 
         /// <summary>
         /// The decoupled clock used for gameplay. Should be used for seeks and clock control.
         /// </summary>
-        private readonly DecoupleableInterpolatingFramedClock adjustableClock;
+        protected readonly DecoupleableInterpolatingFramedClock AdjustableClock;
 
-        private readonly double gameplayStartTime;
+        protected GameplayClockContainer(IClock sourceClock)
-        private readonly bool startAtGameplayStart;
-
-        private readonly double firstHitObjectTime;
-
-        public readonly BindableNumber<double> UserPlaybackRate = new BindableDouble(1)
         {
-            Default = 1,
-            MinValue = 0.5,
-            MaxValue = 2,
-            Precision = 0.1,
-        };
-
-        /// <summary>
-        /// The final clock which is exposed to underlying components.
-        /// </summary>
-        public GameplayClock GameplayClock => localGameplayClock;
-
-        [Cached(typeof(GameplayClock))]
-        private readonly LocalGameplayClock localGameplayClock;
-
-        private Bindable<double> userAudioOffset;
-
-        private readonly FramedOffsetClock userOffsetClock;
-
-        private readonly FramedOffsetClock platformOffsetClock;
-
-        /// <summary>
-        /// Creates a new <see cref="GameplayClockContainer"/>.
-        /// </summary>
-        /// <param name="beatmap">The beatmap being played.</param>
-        /// <param name="gameplayStartTime">The suggested time to start gameplay at.</param>
-        /// <param name="startAtGameplayStart">
-        /// Whether <paramref name="gameplayStartTime"/> should be used regardless of when storyboard events and hitobjects are supposed to start.
-        /// </param>
-        public GameplayClockContainer(WorkingBeatmap beatmap, double gameplayStartTime, bool startAtGameplayStart = false)
-        {
-            this.beatmap = beatmap;
-            this.gameplayStartTime = gameplayStartTime;
-            this.startAtGameplayStart = startAtGameplayStart;
-            track = beatmap.Track;
-
-            firstHitObjectTime = beatmap.Beatmap.HitObjects.First().StartTime;
-
             RelativeSizeAxes = Axes.Both;
 
-            adjustableClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
+            AdjustableClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
+            AdjustableClock.ChangeSource(sourceClock);
 
-            // Lazer's audio timings in general doesn't match stable. This is the result of user testing, albeit limited.
+            IsPaused.BindValueChanged(OnIsPausedChanged);
-            // This only seems to be required on windows. We need to eventually figure out why, with a bit of luck.
+        }
-            platformOffsetClock = new HardwareCorrectionOffsetClock(adjustableClock) { Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 15 : 0 };
 
-            // the final usable gameplay clock with user-set offsets applied.
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
-            userOffsetClock = new HardwareCorrectionOffsetClock(platformOffsetClock);
+        {
-
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-            // the clock to be exposed via DI to children.
-            localGameplayClock = new LocalGameplayClock(userOffsetClock);
 
+            dependencies.CacheAs(GameplayClock = CreateGameplayClock(AdjustableClock));
             GameplayClock.IsPaused.BindTo(IsPaused);
 
-            IsPaused.BindValueChanged(onPauseChanged);
+            return dependencies;
         }
 
-        private void onPauseChanged(ValueChangedEvent<bool> isPaused)
+        public virtual void Start()
         {
-            if (isPaused.NewValue)
+            if (!AdjustableClock.IsRunning)
-                this.TransformBindableTo(pauseFreqAdjust, 0, 200, Easing.Out).OnComplete(_ => adjustableClock.Stop());
-            else
-                this.TransformBindableTo(pauseFreqAdjust, 1, 200, Easing.In);
-        }
-
-        private double totalOffset => userOffsetClock.Offset + platformOffsetClock.Offset;
-
-        /// <summary>
-        /// Duration before gameplay start time required before skip button displays.
-        /// </summary>
-        public const double MINIMUM_SKIP_TIME = 1000;
-
-        private readonly BindableDouble pauseFreqAdjust = new BindableDouble(1);
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            userAudioOffset = config.GetBindable<double>(OsuSetting.AudioOffset);
-            userAudioOffset.BindValueChanged(offset => userOffsetClock.Offset = offset.NewValue, true);
-
-            // sane default provided by ruleset.
-            double startTime = gameplayStartTime;
-
-            if (!startAtGameplayStart)
-            {
-                startTime = Math.Min(0, startTime);
-
-                // if a storyboard is present, it may dictate the appropriate start time by having events in negative time space.
-                // this is commonly used to display an intro before the audio track start.
-                double? firstStoryboardEvent = beatmap.Storyboard.EarliestEventTime;
-                if (firstStoryboardEvent != null)
-                    startTime = Math.Min(startTime, firstStoryboardEvent.Value);
-
-                // some beatmaps specify a current lead-in time which should be used instead of the ruleset-provided value when available.
-                // this is not available as an option in the live editor but can still be applied via .osu editing.
-                if (beatmap.BeatmapInfo.AudioLeadIn > 0)
-                    startTime = Math.Min(startTime, firstHitObjectTime - beatmap.BeatmapInfo.AudioLeadIn);
-            }
-
-            Seek(startTime);
-
-            adjustableClock.ProcessFrame();
-        }
-
-        public void Restart()
-        {
-            Task.Run(() =>
-            {
-                track.Seek(0);
-                track.Stop();
-
-                Schedule(() =>
-                {
-                    adjustableClock.ChangeSource(track);
-                    updateRate();
-
-                    if (!IsPaused.Value)
-                        Start();
-                });
-            });
-        }
-
-        public void Start()
-        {
-            if (!adjustableClock.IsRunning)
             {
                 // Seeking the decoupled clock to its current time ensures that its source clock will be seeked to the same time
-                // This accounts for the audio clock source potentially taking time to enter a completely stopped state
+                // This accounts for the clock source potentially taking time to enter a completely stopped state
                 Seek(GameplayClock.CurrentTime);
 
-                adjustableClock.Start();
+                AdjustableClock.Start();
             }
 
             IsPaused.Value = false;
         }
 
-        /// <summary>
-        /// Skip forward to the next valid skip point.
-        /// </summary>
-        public void Skip()
-        {
-            if (GameplayClock.CurrentTime > gameplayStartTime - MINIMUM_SKIP_TIME)
-                return;
-
-            double skipTarget = gameplayStartTime - MINIMUM_SKIP_TIME;
-
-            if (GameplayClock.CurrentTime < 0 && skipTarget > 6000)
-                // double skip exception for storyboards with very long intros
-                skipTarget = 0;
-
-            Seek(skipTarget);
-        }
-
         /// <summary>
         /// Seek to a specific time in gameplay.
         /// <remarks>
@@ -202,99 +64,21 @@ namespace osu.Game.Screens.Play
         /// </remarks>
         /// </summary>
         /// <param name="time">The destination time to seek to.</param>
-        public void Seek(double time)
+        public virtual void Seek(double time) => AdjustableClock.Seek(time);
+
+        public virtual void Stop() => IsPaused.Value = true;
+
+        public virtual void Restart()
         {
-            // remove the offset component here because most of the time we want the seek to be aligned to gameplay, not the audio track.
+            AdjustableClock.Seek(0);
-            // we may want to consider reversing the application of offsets in the future as it may feel more correct.
+            AdjustableClock.Stop();
-            adjustableClock.Seek(time - totalOffset);
 
-            // manually process frame to ensure GameplayClock is correctly updated after a seek.
-            userOffsetClock.ProcessFrame();
-        }
-
-        public void Stop()
-        {
-            IsPaused.Value = true;
-        }
-
-        /// <summary>
-        /// Changes the backing clock to avoid using the originally provided track.
-        /// </summary>
-        public void StopUsingBeatmapClock()
-        {
-            removeSourceClockAdjustments();
-
-            track = new TrackVirtual(track.Length);
-            adjustableClock.ChangeSource(track);
-        }
-
-        protected override void Update()
-        {
             if (!IsPaused.Value)
-            {
+                Start();
-                userOffsetClock.ProcessFrame();
-            }
-
-            base.Update();
         }
 
-        private bool speedAdjustmentsApplied;
+        protected abstract void OnIsPausedChanged(ValueChangedEvent<bool> isPaused);
 
-        private void updateRate()
+        protected abstract GameplayClock CreateGameplayClock(IClock source);
-        {
-            if (speedAdjustmentsApplied)
-                return;
-
-            track.AddAdjustment(AdjustableProperty.Frequency, pauseFreqAdjust);
-            track.AddAdjustment(AdjustableProperty.Tempo, UserPlaybackRate);
-
-            localGameplayClock.MutableNonGameplayAdjustments.Add(pauseFreqAdjust);
-            localGameplayClock.MutableNonGameplayAdjustments.Add(UserPlaybackRate);
-
-            speedAdjustmentsApplied = true;
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-            removeSourceClockAdjustments();
-        }
-
-        private void removeSourceClockAdjustments()
-        {
-            if (!speedAdjustmentsApplied) return;
-
-            track.RemoveAdjustment(AdjustableProperty.Frequency, pauseFreqAdjust);
-            track.RemoveAdjustment(AdjustableProperty.Tempo, UserPlaybackRate);
-
-            localGameplayClock.MutableNonGameplayAdjustments.Remove(pauseFreqAdjust);
-            localGameplayClock.MutableNonGameplayAdjustments.Remove(UserPlaybackRate);
-
-            speedAdjustmentsApplied = false;
-        }
-
-        private class LocalGameplayClock : GameplayClock
-        {
-            public readonly List<Bindable<double>> MutableNonGameplayAdjustments = new List<Bindable<double>>();
-
-            public override IEnumerable<Bindable<double>> NonGameplayAdjustments => MutableNonGameplayAdjustments;
-
-            public LocalGameplayClock(FramedOffsetClock underlyingClock)
-                : base(underlyingClock)
-            {
-            }
-        }
-
-        private class HardwareCorrectionOffsetClock : FramedOffsetClock
-        {
-            // we always want to apply the same real-time offset, so it should be adjusted by the difference in playback rate (from realtime) to achieve this.
-            // base implementation already adds offset at 1.0 rate, so we only add the difference from that here.
-            public override double CurrentTime => base.CurrentTime + Offset * (Rate - 1);
-
-            public HardwareCorrectionOffsetClock(IClock source, bool processSource = true)
-                : base(source, processSource)
-            {
-            }
-        }
     }
 }

osu.Game/Screens/Play/MasterGameplayClockContainer.cs

@@ -0,0 +1,220 @@
+// 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;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Track;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+
+namespace osu.Game.Screens.Play
+{
+    public class MasterGameplayClockContainer : GameplayClockContainer
+    {
+        /// <summary>
+        /// Duration before gameplay start time required before skip button displays.
+        /// </summary>
+        public const double MINIMUM_SKIP_TIME = 1000;
+
+        protected Track Track => (Track)AdjustableClock.Source;
+
+        public readonly BindableNumber<double> UserPlaybackRate = new BindableDouble(1)
+        {
+            Default = 1,
+            MinValue = 0.5,
+            MaxValue = 2,
+            Precision = 0.1,
+        };
+
+        private double totalOffset => userOffsetClock.Offset + platformOffsetClock.Offset;
+
+        private readonly BindableDouble pauseFreqAdjust = new BindableDouble(1);
+
+        private readonly WorkingBeatmap beatmap;
+        private readonly double gameplayStartTime;
+        private readonly bool startAtGameplayStart;
+        private readonly double firstHitObjectTime;
+
+        private FramedOffsetClock userOffsetClock;
+        private FramedOffsetClock platformOffsetClock;
+        private LocalGameplayClock localGameplayClock;
+        private Bindable<double> userAudioOffset;
+
+        public MasterGameplayClockContainer(WorkingBeatmap beatmap, double gameplayStartTime, bool startAtGameplayStart = false)
+            : base(beatmap.Track)
+        {
+            this.beatmap = beatmap;
+            this.gameplayStartTime = gameplayStartTime;
+            this.startAtGameplayStart = startAtGameplayStart;
+
+            firstHitObjectTime = beatmap.Beatmap.HitObjects.First().StartTime;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            userAudioOffset = config.GetBindable<double>(OsuSetting.AudioOffset);
+            userAudioOffset.BindValueChanged(offset => userOffsetClock.Offset = offset.NewValue, true);
+
+            // sane default provided by ruleset.
+            double startTime = gameplayStartTime;
+
+            if (!startAtGameplayStart)
+            {
+                startTime = Math.Min(0, startTime);
+
+                // if a storyboard is present, it may dictate the appropriate start time by having events in negative time space.
+                // this is commonly used to display an intro before the audio track start.
+                double? firstStoryboardEvent = beatmap.Storyboard.EarliestEventTime;
+                if (firstStoryboardEvent != null)
+                    startTime = Math.Min(startTime, firstStoryboardEvent.Value);
+
+                // some beatmaps specify a current lead-in time which should be used instead of the ruleset-provided value when available.
+                // this is not available as an option in the live editor but can still be applied via .osu editing.
+                if (beatmap.BeatmapInfo.AudioLeadIn > 0)
+                    startTime = Math.Min(startTime, firstHitObjectTime - beatmap.BeatmapInfo.AudioLeadIn);
+            }
+
+            Seek(startTime);
+
+            AdjustableClock.ProcessFrame();
+        }
+
+        protected override void OnIsPausedChanged(ValueChangedEvent<bool> isPaused)
+        {
+            if (isPaused.NewValue)
+                this.TransformBindableTo(pauseFreqAdjust, 0, 200, Easing.Out).OnComplete(_ => AdjustableClock.Stop());
+            else
+                this.TransformBindableTo(pauseFreqAdjust, 1, 200, Easing.In);
+        }
+
+        public override void Seek(double time)
+        {
+            // remove the offset component here because most of the time we want the seek to be aligned to gameplay, not the audio track.
+            // we may want to consider reversing the application of offsets in the future as it may feel more correct.
+            base.Seek(time - totalOffset);
+
+            // manually process frame to ensure GameplayClock is correctly updated after a seek.
+            userOffsetClock.ProcessFrame();
+        }
+
+        public override void Restart()
+        {
+            updateRate();
+            base.Restart();
+        }
+
+        /// <summary>
+        /// Skip forward to the next valid skip point.
+        /// </summary>
+        public void Skip()
+        {
+            if (GameplayClock.CurrentTime > gameplayStartTime - MINIMUM_SKIP_TIME)
+                return;
+
+            double skipTarget = gameplayStartTime - MINIMUM_SKIP_TIME;
+
+            if (GameplayClock.CurrentTime < 0 && skipTarget > 6000)
+                // double skip exception for storyboards with very long intros
+                skipTarget = 0;
+
+            Seek(skipTarget);
+        }
+
+        protected override GameplayClock CreateGameplayClock(IClock source)
+        {
+            // Lazer's audio timings in general doesn't match stable. This is the result of user testing, albeit limited.
+            // This only seems to be required on windows. We need to eventually figure out why, with a bit of luck.
+            platformOffsetClock = new HardwareCorrectionOffsetClock(source) { Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 15 : 0 };
+
+            // the final usable gameplay clock with user-set offsets applied.
+            userOffsetClock = new HardwareCorrectionOffsetClock(platformOffsetClock);
+
+            return localGameplayClock = new LocalGameplayClock(userOffsetClock);
+        }
+
+        protected override void Update()
+        {
+            if (!IsPaused.Value)
+                userOffsetClock.ProcessFrame();
+
+            base.Update();
+        }
+
+        /// <summary>
+        /// Changes the backing clock to avoid using the originally provided track.
+        /// </summary>
+        public void StopUsingBeatmapClock()
+        {
+            removeSourceClockAdjustments();
+            AdjustableClock.ChangeSource(new TrackVirtual(beatmap.Track.Length));
+        }
+
+        private bool speedAdjustmentsApplied;
+
+        private void updateRate()
+        {
+            if (speedAdjustmentsApplied)
+                return;
+
+            Track.AddAdjustment(AdjustableProperty.Frequency, pauseFreqAdjust);
+            Track.AddAdjustment(AdjustableProperty.Tempo, UserPlaybackRate);
+
+            localGameplayClock.MutableNonGameplayAdjustments.Add(pauseFreqAdjust);
+            localGameplayClock.MutableNonGameplayAdjustments.Add(UserPlaybackRate);
+
+            speedAdjustmentsApplied = true;
+        }
+
+        private void removeSourceClockAdjustments()
+        {
+            if (!speedAdjustmentsApplied)
+                return;
+
+            Track.RemoveAdjustment(AdjustableProperty.Frequency, pauseFreqAdjust);
+            Track.RemoveAdjustment(AdjustableProperty.Tempo, UserPlaybackRate);
+
+            localGameplayClock.MutableNonGameplayAdjustments.Remove(pauseFreqAdjust);
+            localGameplayClock.MutableNonGameplayAdjustments.Remove(UserPlaybackRate);
+
+            speedAdjustmentsApplied = false;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            removeSourceClockAdjustments();
+        }
+
+        private class HardwareCorrectionOffsetClock : FramedOffsetClock
+        {
+            // we always want to apply the same real-time offset, so it should be adjusted by the difference in playback rate (from realtime) to achieve this.
+            // base implementation already adds offset at 1.0 rate, so we only add the difference from that here.
+            public override double CurrentTime => base.CurrentTime + Offset * (Rate - 1);
+
+            public HardwareCorrectionOffsetClock(IClock source, bool processSource = true)
+                : base(source, processSource)
+            {
+            }
+        }
+
+        private class LocalGameplayClock : GameplayClock
+        {
+            public readonly List<Bindable<double>> MutableNonGameplayAdjustments = new List<Bindable<double>>();
+
+            public override IEnumerable<Bindable<double>> NonGameplayAdjustments => MutableNonGameplayAdjustments;
+
+            public LocalGameplayClock(FramedOffsetClock underlyingClock)
+                : base(underlyingClock)
+            {
+            }
+        }
+    }
+}

osu.Game/Screens/Play/Player.cs

@@ -295,7 +295,7 @@ namespace osu.Game.Screens.Play
             IsBreakTime.BindValueChanged(onBreakTimeChanged, true);
         }
 
-        protected virtual GameplayClockContainer CreateGameplayClockContainer(WorkingBeatmap beatmap, double gameplayStart) => new GameplayClockContainer(beatmap, gameplayStart);
+        protected virtual GameplayClockContainer CreateGameplayClockContainer(WorkingBeatmap beatmap, double gameplayStart) => new MasterGameplayClockContainer(beatmap, gameplayStart);
 
         private Drawable createUnderlayComponents() =>
             DimmableStoryboard = new DimmableStoryboard(Beatmap.Value.Storyboard) { RelativeSizeAxes = Axes.Both };
@@ -342,7 +342,6 @@ namespace osu.Game.Screens.Play
                             Action = () => PerformExit(true),
                             IsPaused = { BindTarget = GameplayClockContainer.IsPaused }
                         },
-                        PlayerSettingsOverlay = { PlaybackSettings = { UserPlaybackRate = { BindTarget = GameplayClockContainer.UserPlaybackRate } } },
                         KeyCounter =
                         {
                             AlwaysVisible = { BindTarget = DrawableRuleset.HasReplayLoaded },
@@ -386,6 +385,9 @@ namespace osu.Game.Screens.Play
                 }
             };
 
+            if (GameplayClockContainer is MasterGameplayClockContainer master)
+                HUDOverlay.PlayerSettingsOverlay.PlaybackSettings.UserPlaybackRate.BindTarget = master.UserPlaybackRate;
+
             if (!Configuration.AllowSkippingIntro)
                 skipOverlay.Expire();
 
@@ -533,7 +535,8 @@ namespace osu.Game.Screens.Play
             // user requested skip
             // disable sample playback to stop currently playing samples and perform skip
             samplePlaybackDisabled.Value = true;
-            GameplayClockContainer.Skip();
+
+            (GameplayClockContainer as MasterGameplayClockContainer)?.Skip();
 
             // return samplePlaybackDisabled.Value to what is defined by the beatmap's current state
             updateSampleDisabledState();
@@ -832,7 +835,7 @@ namespace osu.Game.Screens.Play
 
             // GameplayClockContainer performs seeks / start / stop operations on the beatmap's track.
             // as we are no longer the current screen, we cannot guarantee the track is still usable.
-            GameplayClockContainer?.StopUsingBeatmapClock();
+            (GameplayClockContainer as MasterGameplayClockContainer)?.StopUsingBeatmapClock();
 
             musicController.ResetTrackAdjustments();
 

osu.Game/Screens/Play/SkipOverlay.cs

@@ -90,7 +90,7 @@ namespace osu.Game.Screens.Play
 
         private const double fade_time = 300;
 
-        private double fadeOutBeginTime => startTime - GameplayClockContainer.MINIMUM_SKIP_TIME;
+        private double fadeOutBeginTime => startTime - MasterGameplayClockContainer.MINIMUM_SKIP_TIME;
 
         protected override void LoadComplete()
         {

osu.Game/Screens/Play/SpectatorPlayer.cs

@@ -61,7 +61,7 @@ namespace osu.Game.Screens.Play
             if (firstFrameTime == null || firstFrameTime <= gameplayStart + 5000)
                 return base.CreateGameplayClockContainer(beatmap, gameplayStart);
 
-            return new GameplayClockContainer(beatmap, firstFrameTime.Value, true);
+            return new MasterGameplayClockContainer(beatmap, firstFrameTime.Value, true);
         }
 
         public override bool OnExiting(IScreen next)