h1or4dme8/osu-lazer
1
0
Fork 0
mirror of https://github.com/ppy/osu.git synced 2025-02-01 22:03:01 +08:00
Code Issues Releases Wiki Activity

Rename spectator clock sync classes

Browse Source
This commit is contained in:
Dean Herbert 2022-08-24 15:07:04 +09:00
parent 31f657fe01
commit 995e6664b6
7 changed files with 47 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
osu.Game.Tests/OnlinePlay/TestSceneCatchUpSyncManager.cs
View File

@ -19,20 +19,20 @@ namespace osu.Game.Tests.OnlinePlay
public class TestSceneCatchUpSyncManager : OsuTestScene public class TestSceneCatchUpSyncManager : OsuTestScene
{ {
private GameplayClockContainer master; private GameplayClockContainer master;
private CatchUpSyncManager syncManager; private SpectatorSyncManager syncManager;
private Dictionary<CatchUpSpectatorPlayerClock, int> clocksById; private Dictionary<SpectatorPlayerClock, int> clocksById;
private CatchUpSpectatorPlayerClock player1; private SpectatorPlayerClock player1;
private CatchUpSpectatorPlayerClock player2; private SpectatorPlayerClock player2;
[SetUp] [SetUp]
public void Setup() public void Setup()
{ {
syncManager = new CatchUpSyncManager(master = new GameplayClockContainer(new TestManualClock())); syncManager = new SpectatorSyncManager(master = new GameplayClockContainer(new TestManualClock()));
player1 = syncManager.CreateManagedClock(); player1 = syncManager.CreateManagedClock();
player2 = syncManager.CreateManagedClock(); player2 = syncManager.CreateManagedClock();
clocksById = new Dictionary<CatchUpSpectatorPlayerClock, int> clocksById = new Dictionary<SpectatorPlayerClock, int>
{ {
{ player1, 1 }, { player1, 1 },
{ player2, 2 } { player2, 2 }
@ -64,7 +64,7 @@ namespace osu.Game.Tests.OnlinePlay
public void TestReadyPlayersStartWhenReadyForMaximumDelayTime() public void TestReadyPlayersStartWhenReadyForMaximumDelayTime()
{ {
setWaiting(() => player1, false); setWaiting(() => player1, false);
AddWaitStep($"wait {CatchUpSyncManager.MAXIMUM_START_DELAY} milliseconds", (int)Math.Ceiling(CatchUpSyncManager.MAXIMUM_START_DELAY / TimePerAction)); AddWaitStep($"wait {SpectatorSyncManager.MAXIMUM_START_DELAY} milliseconds", (int)Math.Ceiling(SpectatorSyncManager.MAXIMUM_START_DELAY / TimePerAction));
assertPlayerClockState(() => player1, true); assertPlayerClockState(() => player1, true);
assertPlayerClockState(() => player2, false); assertPlayerClockState(() => player2, false);
} }
@ -74,7 +74,7 @@ namespace osu.Game.Tests.OnlinePlay
{ {
setAllWaiting(false); setAllWaiting(false);
setMasterTime(CatchUpSyncManager.SYNC_TARGET + 1); setMasterTime(SpectatorSyncManager.SYNC_TARGET + 1);
assertCatchingUp(() => player1, false); assertCatchingUp(() => player1, false);
} }
@ -83,7 +83,7 @@ namespace osu.Game.Tests.OnlinePlay
{ {
setAllWaiting(false); setAllWaiting(false);
setMasterTime(CatchUpSyncManager.MAX_SYNC_OFFSET + 1); setMasterTime(SpectatorSyncManager.MAX_SYNC_OFFSET + 1);
assertCatchingUp(() => player1, true); assertCatchingUp(() => player1, true);
assertCatchingUp(() => player2, true); assertCatchingUp(() => player2, true);
} }
@ -93,8 +93,8 @@ namespace osu.Game.Tests.OnlinePlay
{ {
setAllWaiting(false); setAllWaiting(false);
setMasterTime(CatchUpSyncManager.MAX_SYNC_OFFSET + 1); setMasterTime(SpectatorSyncManager.MAX_SYNC_OFFSET + 1);
setPlayerClockTime(() => player1, CatchUpSyncManager.SYNC_TARGET + 1); setPlayerClockTime(() => player1, SpectatorSyncManager.SYNC_TARGET + 1);
assertCatchingUp(() => player1, true); assertCatchingUp(() => player1, true);
} }
@ -103,8 +103,8 @@ namespace osu.Game.Tests.OnlinePlay
{ {
setAllWaiting(false); setAllWaiting(false);
setMasterTime(CatchUpSyncManager.MAX_SYNC_OFFSET + 2); setMasterTime(SpectatorSyncManager.MAX_SYNC_OFFSET + 2);
setPlayerClockTime(() => player1, CatchUpSyncManager.SYNC_TARGET); setPlayerClockTime(() => player1, SpectatorSyncManager.SYNC_TARGET);
assertCatchingUp(() => player1, false); assertCatchingUp(() => player1, false);
assertCatchingUp(() => player2, true); assertCatchingUp(() => player2, true);
} }
@ -114,7 +114,7 @@ namespace osu.Game.Tests.OnlinePlay
{ {
setAllWaiting(false); setAllWaiting(false);
setPlayerClockTime(() => player1, -CatchUpSyncManager.SYNC_TARGET); setPlayerClockTime(() => player1, -SpectatorSyncManager.SYNC_TARGET);
assertCatchingUp(() => player1, false); assertCatchingUp(() => player1, false);
assertPlayerClockState(() => player1, true); assertPlayerClockState(() => player1, true);
} }
@ -124,7 +124,7 @@ namespace osu.Game.Tests.OnlinePlay
{ {
setAllWaiting(false); setAllWaiting(false);
setPlayerClockTime(() => player1, -CatchUpSyncManager.SYNC_TARGET - 1); setPlayerClockTime(() => player1, -SpectatorSyncManager.SYNC_TARGET - 1);
// This is a silent catchup, where IsCatchingUp = false but IsRunning = false also. // This is a silent catchup, where IsCatchingUp = false but IsRunning = false also.
assertCatchingUp(() => player1, false); assertCatchingUp(() => player1, false);
@ -145,7 +145,7 @@ namespace osu.Game.Tests.OnlinePlay
assertPlayerClockState(() => player1, false); assertPlayerClockState(() => player1, false);
} }
private void setWaiting(Func<CatchUpSpectatorPlayerClock> playerClock, bool waiting) private void setWaiting(Func<SpectatorPlayerClock> playerClock, bool waiting)
=> AddStep($"set player clock {clocksById[playerClock()]} waiting = {waiting}", () => playerClock().WaitingOnFrames.Value = waiting); => AddStep($"set player clock {clocksById[playerClock()]} waiting = {waiting}", () => playerClock().WaitingOnFrames.Value = waiting);
private void setAllWaiting(bool waiting) => AddStep($"set all player clocks waiting = {waiting}", () => private void setAllWaiting(bool waiting) => AddStep($"set all player clocks waiting = {waiting}", () =>
@ -160,13 +160,13 @@ namespace osu.Game.Tests.OnlinePlay
/// <summary> /// <summary>
/// clock.Time = master.Time - offsetFromMaster /// clock.Time = master.Time - offsetFromMaster
/// </summary> /// </summary>
private void setPlayerClockTime(Func<CatchUpSpectatorPlayerClock> playerClock, double offsetFromMaster) private void setPlayerClockTime(Func<SpectatorPlayerClock> playerClock, double offsetFromMaster)
=> AddStep($"set player clock {clocksById[playerClock()]} = master - {offsetFromMaster}", () => playerClock().Seek(master.CurrentTime - offsetFromMaster)); => AddStep($"set player clock {clocksById[playerClock()]} = master - {offsetFromMaster}", () => playerClock().Seek(master.CurrentTime - offsetFromMaster));
private void assertCatchingUp(Func<CatchUpSpectatorPlayerClock> playerClock, bool catchingUp) => private void assertCatchingUp(Func<SpectatorPlayerClock> playerClock, bool catchingUp) =>
AddAssert($"player clock {clocksById[playerClock()]} {(catchingUp ? "is" : "is not")} catching up", () => playerClock().IsCatchingUp == catchingUp); AddAssert($"player clock {clocksById[playerClock()]} {(catchingUp ? "is" : "is not")} catching up", () => playerClock().IsCatchingUp == catchingUp);
private void assertPlayerClockState(Func<CatchUpSpectatorPlayerClock> playerClock, bool running) private void assertPlayerClockState(Func<SpectatorPlayerClock> playerClock, bool running)
=> AddAssert($"player clock {clocksById[playerClock()]} {(running ? "is" : "is not")} running", () => playerClock().IsRunning == running); => AddAssert($"player clock {clocksById[playerClock()]} {(running ? "is" : "is not")} running", () => playerClock().IsRunning == running);
private class TestManualClock : ManualClock, IAdjustableClock private class TestManualClock : ManualClock, IAdjustableClock

4
osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs
View File

@ -202,7 +202,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
checkPausedInstant(PLAYER_2_ID, true); checkPausedInstant(PLAYER_2_ID, true);
// Wait for the start delay seconds... // Wait for the start delay seconds...
AddWaitStep("wait maximum start delay seconds", (int)(CatchUpSyncManager.MAXIMUM_START_DELAY / TimePerAction)); AddWaitStep("wait maximum start delay seconds", (int)(SpectatorSyncManager.MAXIMUM_START_DELAY / TimePerAction));
// Player 1 should start playing by itself, player 2 should remain paused. // Player 1 should start playing by itself, player 2 should remain paused.
checkPausedInstant(PLAYER_1_ID, false); checkPausedInstant(PLAYER_1_ID, false);
@ -318,7 +318,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
loadSpectateScreen(); loadSpectateScreen();
sendFrames(PLAYER_1_ID, 300); sendFrames(PLAYER_1_ID, 300);
AddWaitStep("wait maximum start delay seconds", (int)(CatchUpSyncManager.MAXIMUM_START_DELAY / TimePerAction)); AddWaitStep("wait maximum start delay seconds", (int)(SpectatorSyncManager.MAXIMUM_START_DELAY / TimePerAction));
checkPaused(PLAYER_1_ID, false); checkPaused(PLAYER_1_ID, false);
sendFrames(PLAYER_2_ID, 300); sendFrames(PLAYER_2_ID, 300);

8
osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorPlayer.cs
View File

@ -15,14 +15,14 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
public class MultiSpectatorPlayer : SpectatorPlayer public class MultiSpectatorPlayer : SpectatorPlayer
{ {
private readonly Bindable<bool> waitingOnFrames = new Bindable<bool>(true); private readonly Bindable<bool> waitingOnFrames = new Bindable<bool>(true);
private readonly CatchUpSpectatorPlayerClock spectatorPlayerClock; private readonly SpectatorPlayerClock spectatorPlayerClock;
/// <summary> /// <summary>
/// Creates a new <see cref="MultiSpectatorPlayer"/>. /// Creates a new <see cref="MultiSpectatorPlayer"/>.
/// </summary> /// </summary>
/// <param name="score">The score containing the player's replay.</param> /// <param name="score">The score containing the player's replay.</param>
/// <param name="spectatorPlayerClock">The clock controlling the gameplay running state.</param> /// <param name="spectatorPlayerClock">The clock controlling the gameplay running state.</param>
public MultiSpectatorPlayer(Score score, CatchUpSpectatorPlayerClock spectatorPlayerClock) public MultiSpectatorPlayer(Score score, SpectatorPlayerClock spectatorPlayerClock)
: base(score, new PlayerConfiguration { AllowUserInteraction = false }) : base(score, new PlayerConfiguration { AllowUserInteraction = false })
{ {
this.spectatorPlayerClock = spectatorPlayerClock; this.spectatorPlayerClock = spectatorPlayerClock;
@ -40,9 +40,9 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
protected override void Update() protected override void Update()
{ {
// The player clock's running state is controlled externally, but the local pausing state needs to be updated to start/stop gameplay. // The player clock's running state is controlled externally, but the local pausing state needs to be updated to start/stop gameplay.
CatchUpSpectatorPlayerClock catchUpClock = (CatchUpSpectatorPlayerClock)GameplayClockContainer.SourceClock; SpectatorPlayerClock clock = (SpectatorPlayerClock)GameplayClockContainer.SourceClock;
if (catchUpClock.IsRunning) if (clock.IsRunning)
GameplayClockContainer.Start(); GameplayClockContainer.Start();
else else
GameplayClockContainer.Stop(); GameplayClockContainer.Stop();

6
osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs
View File

@ -48,7 +48,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
private readonly PlayerArea[] instances; private readonly PlayerArea[] instances;
private MasterGameplayClockContainer masterClockContainer = null!; private MasterGameplayClockContainer masterClockContainer = null!;
private CatchUpSyncManager syncManager = null!; private SpectatorSyncManager syncManager = null!;
private PlayerGrid grid = null!; private PlayerGrid grid = null!;
private MultiSpectatorLeaderboard leaderboard = null!; private MultiSpectatorLeaderboard leaderboard = null!;
private PlayerArea? currentAudioSource; private PlayerArea? currentAudioSource;
@ -81,7 +81,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
InternalChildren = new[] InternalChildren = new[]
{ {
(Drawable)(syncManager = new CatchUpSyncManager(masterClockContainer)), (Drawable)(syncManager = new SpectatorSyncManager(masterClockContainer)),
masterClockContainer.WithChild(new GridContainer masterClockContainer.WithChild(new GridContainer
{ {
RelativeSizeAxes = Axes.Both, RelativeSizeAxes = Axes.Both,
@ -177,7 +177,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
} }
} }
private bool isCandidateAudioSource(CatchUpSpectatorPlayerClock? clock) private bool isCandidateAudioSource(SpectatorPlayerClock? clock)
=> clock?.IsRunning == true && !clock.IsCatchingUp && !clock.WaitingOnFrames.Value; => clock?.IsRunning == true && !clock.IsCatchingUp && !clock.WaitingOnFrames.Value;
private void onReadyToStart() private void onReadyToStart()

6
osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/PlayerArea.cs
View File

@ -38,9 +38,9 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
public readonly int UserId; public readonly int UserId;
/// <summary> /// <summary>
/// The <see cref="CatchUpSpectatorPlayerClock"/> used to control the gameplay running state of a loaded <see cref="Player"/>. /// The <see cref="SpectatorPlayerClock"/> used to control the gameplay running state of a loaded <see cref="Player"/>.
/// </summary> /// </summary>
public readonly CatchUpSpectatorPlayerClock GameplayClock; public readonly SpectatorPlayerClock GameplayClock;
/// <summary> /// <summary>
/// The currently-loaded score. /// The currently-loaded score.
@ -55,7 +55,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
private readonly LoadingLayer loadingLayer; private readonly LoadingLayer loadingLayer;
private OsuScreenStack? stack; private OsuScreenStack? stack;
public PlayerArea(int userId, CatchUpSpectatorPlayerClock clock) public PlayerArea(int userId, SpectatorPlayerClock clock)
{ {
UserId = userId; UserId = userId;
GameplayClock = clock; GameplayClock = clock;

10
osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/CatchUpSpectatorPlayerClock.cs → osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/SpectatorPlayerClock.cs
View File

@ -9,9 +9,9 @@ using osu.Game.Screens.Play;
namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
{ {
/// <summary> /// <summary>
/// A <see cref="CatchUpSpectatorPlayerClock"/> which catches up using rate adjustment. /// A clock which catches up using rate adjustment.
/// </summary> /// </summary>
public class CatchUpSpectatorPlayerClock : IFrameBasedClock, IAdjustableClock public class SpectatorPlayerClock : IFrameBasedClock, IAdjustableClock
{ {
/// <summary> /// <summary>
/// The catch up rate. /// The catch up rate.
@ -24,7 +24,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
public bool IsRunning { get; private set; } public bool IsRunning { get; private set; }
public CatchUpSpectatorPlayerClock(GameplayClockContainer masterClock) public SpectatorPlayerClock(GameplayClockContainer masterClock)
{ {
this.masterClock = masterClock; this.masterClock = masterClock;
} }
@ -32,12 +32,12 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
public void Reset() => CurrentTime = 0; public void Reset() => CurrentTime = 0;
/// <summary> /// <summary>
/// Starts this <see cref="CatchUpSpectatorPlayerClock"/>. /// Starts this <see cref="SpectatorPlayerClock"/>.
/// </summary> /// </summary>
public void Start() => IsRunning = true; public void Start() => IsRunning = true;
/// <summary> /// <summary>
/// Stops this <see cref="CatchUpSpectatorPlayerClock"/>. /// Stops this <see cref="SpectatorPlayerClock"/>.
/// </summary> /// </summary>
public void Stop() => IsRunning = false; public void Stop() => IsRunning = false;

22
osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/CatchUpSyncManager.cs → osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/SpectatorSyncManager.cs
View File

@ -11,9 +11,9 @@ using osu.Game.Screens.Play;
namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
{ {
/// <summary> /// <summary>
/// Manages the synchronisation between one or more <see cref="CatchUpSpectatorPlayerClock"/>s in relation to a master clock. /// Manages the synchronisation between one or more <see cref="SpectatorPlayerClock"/>s in relation to a master clock.
/// </summary> /// </summary>
public class CatchUpSyncManager : Component public class SpectatorSyncManager : Component
{ {
/// <summary> /// <summary>
/// The offset from the master clock to which player clocks should remain within to be considered in-sync. /// The offset from the master clock to which player clocks should remain within to be considered in-sync.
@ -48,34 +48,34 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
/// <summary> /// <summary>
/// The player clocks. /// The player clocks.
/// </summary> /// </summary>
private readonly List<CatchUpSpectatorPlayerClock> playerClocks = new List<CatchUpSpectatorPlayerClock>(); private readonly List<SpectatorPlayerClock> playerClocks = new List<SpectatorPlayerClock>();
private readonly Bindable<MasterClockState> masterState = new Bindable<MasterClockState>(); private readonly Bindable<MasterClockState> masterState = new Bindable<MasterClockState>();
private bool hasStarted; private bool hasStarted;
private double? firstStartAttemptTime; private double? firstStartAttemptTime;
public CatchUpSyncManager(GameplayClockContainer master) public SpectatorSyncManager(GameplayClockContainer master)
{ {
MasterClock = master; MasterClock = master;
} }
/// <summary> /// <summary>
/// Create a new managed <see cref="CatchUpSpectatorPlayerClock"/>. /// Create a new managed <see cref="SpectatorPlayerClock"/>.
/// </summary> /// </summary>
/// <returns>The newly created <see cref="CatchUpSpectatorPlayerClock"/>.</returns> /// <returns>The newly created <see cref="SpectatorPlayerClock"/>.</returns>
public CatchUpSpectatorPlayerClock CreateManagedClock() public SpectatorPlayerClock CreateManagedClock()
{ {
var clock = new CatchUpSpectatorPlayerClock(MasterClock); var clock = new SpectatorPlayerClock(MasterClock);
playerClocks.Add(clock); playerClocks.Add(clock);
return clock; return clock;
} }
/// <summary> /// <summary>
/// Removes an <see cref="CatchUpSpectatorPlayerClock"/>, stopping it from being managed by this <see cref="CatchUpSyncManager"/>. /// Removes an <see cref="SpectatorPlayerClock"/>, stopping it from being managed by this <see cref="SpectatorSyncManager"/>.
/// </summary> /// </summary>
/// <param name="clock">The <see cref="CatchUpSpectatorPlayerClock"/> to remove.</param> /// <param name="clock">The <see cref="SpectatorPlayerClock"/> to remove.</param>
public void RemoveManagedClock(CatchUpSpectatorPlayerClock clock) public void RemoveManagedClock(SpectatorPlayerClock clock)
{ {
playerClocks.Remove(clock); playerClocks.Remove(clock);
clock.Stop(); clock.Stop();