2019-03-06 19:30:14 +08:00
|
|
|
// 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.
|
|
|
|
|
2021-04-15 18:07:25 +08:00
|
|
|
using System;
|
2019-03-06 19:30:14 +08:00
|
|
|
using osu.Framework.Allocation;
|
|
|
|
using osu.Framework.Bindables;
|
|
|
|
using osu.Framework.Graphics;
|
|
|
|
using osu.Framework.Graphics.Containers;
|
|
|
|
using osu.Framework.Timing;
|
|
|
|
|
|
|
|
namespace osu.Game.Screens.Play
|
|
|
|
{
|
2021-04-16 19:33:29 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Encapsulates gameplay timing logic and provides a <see cref="GameplayClock"/> via DI for gameplay components to use.
|
|
|
|
/// </summary>
|
2021-09-20 22:28:58 +08:00
|
|
|
[Cached]
|
2021-04-15 18:07:25 +08:00
|
|
|
public abstract class GameplayClockContainer : Container, IAdjustableClock
|
2019-03-06 19:30:14 +08:00
|
|
|
{
|
2021-04-14 16:47:11 +08:00
|
|
|
/// <summary>
|
2021-04-16 19:33:29 +08:00
|
|
|
/// The final clock which is exposed to gameplay components.
|
2021-04-14 16:47:11 +08:00
|
|
|
/// </summary>
|
|
|
|
public GameplayClock GameplayClock { get; private set; }
|
2019-03-06 19:30:14 +08:00
|
|
|
|
2021-04-16 19:33:29 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Whether gameplay is paused.
|
|
|
|
/// </summary>
|
2019-03-06 19:30:14 +08:00
|
|
|
public readonly BindableBool IsPaused = new BindableBool();
|
|
|
|
|
|
|
|
/// <summary>
|
2021-04-16 19:33:29 +08:00
|
|
|
/// The adjustable source clock used for gameplay. Should be used for seeks and clock control.
|
2019-03-06 19:30:14 +08:00
|
|
|
/// </summary>
|
2021-04-16 19:33:29 +08:00
|
|
|
protected readonly DecoupleableInterpolatingFramedClock AdjustableSource;
|
2019-03-06 19:30:14 +08:00
|
|
|
|
2021-04-19 18:55:59 +08:00
|
|
|
/// <summary>
|
|
|
|
/// The source clock.
|
|
|
|
/// </summary>
|
|
|
|
protected IClock SourceClock { get; private set; }
|
|
|
|
|
2021-09-20 22:28:58 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Invoked when a seek has been performed via <see cref="Seek"/>
|
|
|
|
/// </summary>
|
|
|
|
public event Action OnSeek;
|
|
|
|
|
2021-04-16 19:33:29 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Creates a new <see cref="GameplayClockContainer"/>.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="sourceClock">The source <see cref="IClock"/> used for timing.</param>
|
2021-04-14 16:47:11 +08:00
|
|
|
protected GameplayClockContainer(IClock sourceClock)
|
2019-03-06 19:30:14 +08:00
|
|
|
{
|
2021-04-19 18:55:59 +08:00
|
|
|
SourceClock = sourceClock;
|
|
|
|
|
2021-04-14 16:47:11 +08:00
|
|
|
RelativeSizeAxes = Axes.Both;
|
2019-03-06 19:30:14 +08:00
|
|
|
|
2021-04-16 19:33:29 +08:00
|
|
|
AdjustableSource = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
|
2021-04-14 18:50:22 +08:00
|
|
|
IsPaused.BindValueChanged(OnIsPausedChanged);
|
2021-04-14 16:47:11 +08:00
|
|
|
}
|
2019-03-06 19:30:14 +08:00
|
|
|
|
2021-04-14 16:47:11 +08:00
|
|
|
protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
|
2019-03-06 19:30:14 +08:00
|
|
|
{
|
2021-04-14 16:47:11 +08:00
|
|
|
var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
|
2020-08-06 17:31:08 +08:00
|
|
|
|
2021-04-16 19:33:29 +08:00
|
|
|
dependencies.CacheAs(GameplayClock = CreateGameplayClock(AdjustableSource));
|
2021-04-14 17:29:34 +08:00
|
|
|
GameplayClock.IsPaused.BindTo(IsPaused);
|
2019-03-06 19:30:14 +08:00
|
|
|
|
2021-04-14 16:47:11 +08:00
|
|
|
return dependencies;
|
|
|
|
}
|
2019-03-06 19:30:14 +08:00
|
|
|
|
2021-04-16 19:33:29 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Starts gameplay.
|
|
|
|
/// </summary>
|
2021-04-14 16:47:11 +08:00
|
|
|
public virtual void Start()
|
|
|
|
{
|
2021-04-24 03:56:08 +08:00
|
|
|
ensureSourceClockSet();
|
2021-04-20 12:56:13 +08:00
|
|
|
|
2021-04-16 19:33:29 +08:00
|
|
|
if (!AdjustableSource.IsRunning)
|
2021-04-14 16:47:11 +08:00
|
|
|
{
|
|
|
|
// Seeking the decoupled clock to its current time ensures that its source clock will be seeked to the same time
|
|
|
|
// This accounts for the clock source potentially taking time to enter a completely stopped state
|
|
|
|
Seek(GameplayClock.CurrentTime);
|
2019-03-06 19:30:14 +08:00
|
|
|
|
2021-04-16 19:33:29 +08:00
|
|
|
AdjustableSource.Start();
|
2021-04-14 16:47:11 +08:00
|
|
|
}
|
2019-03-06 19:30:14 +08:00
|
|
|
|
2021-04-14 16:47:11 +08:00
|
|
|
IsPaused.Value = false;
|
|
|
|
}
|
2019-03-25 19:25:47 +08:00
|
|
|
|
2021-04-14 16:47:11 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Seek to a specific time in gameplay.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="time">The destination time to seek to.</param>
|
2021-04-20 16:35:59 +08:00
|
|
|
public virtual void Seek(double time)
|
|
|
|
{
|
|
|
|
AdjustableSource.Seek(time);
|
|
|
|
|
|
|
|
// Manually process to make sure the gameplay clock is correctly updated after a seek.
|
|
|
|
GameplayClock.UnderlyingClock.ProcessFrame();
|
2021-09-20 22:28:58 +08:00
|
|
|
|
|
|
|
OnSeek?.Invoke();
|
2021-04-20 16:35:59 +08:00
|
|
|
}
|
2020-12-10 16:42:47 +08:00
|
|
|
|
2021-04-16 19:33:29 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Stops gameplay.
|
|
|
|
/// </summary>
|
2021-04-14 16:47:11 +08:00
|
|
|
public virtual void Stop() => IsPaused.Value = true;
|
2020-12-10 16:42:47 +08:00
|
|
|
|
2021-04-16 19:33:29 +08:00
|
|
|
/// <summary>
|
2021-04-19 18:53:55 +08:00
|
|
|
/// Resets this <see cref="GameplayClockContainer"/> and the source to an initial state ready for gameplay.
|
2021-04-16 19:33:29 +08:00
|
|
|
/// </summary>
|
2021-04-19 18:53:55 +08:00
|
|
|
public virtual void Reset()
|
2020-12-10 16:42:47 +08:00
|
|
|
{
|
2021-04-24 03:56:08 +08:00
|
|
|
ensureSourceClockSet();
|
2021-04-20 17:25:46 +08:00
|
|
|
Seek(0);
|
2021-04-14 16:47:11 +08:00
|
|
|
|
2021-04-20 16:36:24 +08:00
|
|
|
// Manually stop the source in order to not affect the IsPaused state.
|
2021-04-16 19:33:29 +08:00
|
|
|
AdjustableSource.Stop();
|
2021-04-14 16:47:11 +08:00
|
|
|
|
|
|
|
if (!IsPaused.Value)
|
|
|
|
Start();
|
2019-03-06 19:30:14 +08:00
|
|
|
}
|
|
|
|
|
2021-04-19 18:55:59 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Changes the source clock.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="sourceClock">The new source.</param>
|
|
|
|
protected void ChangeSource(IClock sourceClock) => AdjustableSource.ChangeSource(SourceClock = sourceClock);
|
|
|
|
|
2021-04-24 03:56:08 +08:00
|
|
|
/// <summary>
|
2021-04-24 20:19:39 +08:00
|
|
|
/// Ensures that the <see cref="AdjustableSource"/> is set to <see cref="SourceClock"/>, if it hasn't been given a source yet.
|
2021-04-24 03:56:08 +08:00
|
|
|
/// This is usually done before a seek to avoid accidentally seeking only the adjustable source in decoupled mode,
|
|
|
|
/// but not the actual source clock.
|
|
|
|
/// That will pretty much only happen on the very first call of this method, as the source clock is passed in the constructor,
|
|
|
|
/// but it is not yet set on the adjustable source there.
|
|
|
|
/// </summary>
|
2021-04-24 20:19:39 +08:00
|
|
|
private void ensureSourceClockSet()
|
|
|
|
{
|
|
|
|
if (AdjustableSource.Source == null)
|
|
|
|
ChangeSource(SourceClock);
|
|
|
|
}
|
2021-04-24 03:56:08 +08:00
|
|
|
|
2021-04-14 20:15:14 +08:00
|
|
|
protected override void Update()
|
|
|
|
{
|
|
|
|
if (!IsPaused.Value)
|
2021-04-16 19:15:42 +08:00
|
|
|
GameplayClock.UnderlyingClock.ProcessFrame();
|
2021-04-14 20:15:14 +08:00
|
|
|
|
|
|
|
base.Update();
|
|
|
|
}
|
|
|
|
|
2021-04-16 19:33:29 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Invoked when the value of <see cref="IsPaused"/> is changed to start or stop the <see cref="AdjustableSource"/> clock.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="isPaused">Whether the clock should now be paused.</param>
|
|
|
|
protected virtual void OnIsPausedChanged(ValueChangedEvent<bool> isPaused)
|
|
|
|
{
|
|
|
|
if (isPaused.NewValue)
|
|
|
|
AdjustableSource.Stop();
|
|
|
|
else
|
|
|
|
AdjustableSource.Start();
|
|
|
|
}
|
2021-04-14 16:47:11 +08:00
|
|
|
|
2021-04-16 19:33:29 +08:00
|
|
|
/// <summary>
|
|
|
|
/// Creates the final <see cref="GameplayClock"/> which is exposed via DI to be used by gameplay components.
|
|
|
|
/// </summary>
|
|
|
|
/// <remarks>
|
|
|
|
/// Any intermediate clocks such as platform offsets should be applied here.
|
|
|
|
/// </remarks>
|
|
|
|
/// <param name="source">The <see cref="IFrameBasedClock"/> providing the source time.</param>
|
|
|
|
/// <returns>The final <see cref="GameplayClock"/>.</returns>
|
2021-04-14 20:15:14 +08:00
|
|
|
protected abstract GameplayClock CreateGameplayClock(IFrameBasedClock source);
|
2021-04-15 18:07:25 +08:00
|
|
|
|
|
|
|
#region IAdjustableClock
|
|
|
|
|
|
|
|
bool IAdjustableClock.Seek(double position)
|
|
|
|
{
|
|
|
|
Seek(position);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-04-21 16:13:01 +08:00
|
|
|
void IAdjustableClock.Reset() => Reset();
|
2021-04-15 18:07:25 +08:00
|
|
|
|
|
|
|
public void ResetSpeedAdjustments()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
double IAdjustableClock.Rate
|
|
|
|
{
|
|
|
|
get => GameplayClock.Rate;
|
|
|
|
set => throw new NotSupportedException();
|
|
|
|
}
|
|
|
|
|
|
|
|
double IClock.Rate => GameplayClock.Rate;
|
|
|
|
|
|
|
|
public double CurrentTime => GameplayClock.CurrentTime;
|
|
|
|
|
|
|
|
public bool IsRunning => GameplayClock.IsRunning;
|
|
|
|
|
|
|
|
#endregion
|
2021-04-14 16:47:11 +08:00
|
|
|
}
|
2019-03-06 19:30:14 +08:00
|
|
|
}
|