1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-15 12:42:54 +08:00
osu-lazer/osu.Game/Screens/OsuScreen.cs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

296 lines
10 KiB
C#
Raw Normal View History

// 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.
2018-04-13 17:19:50 +08:00
2022-06-17 15:37:17 +08:00
#nullable disable
using System;
2019-04-08 17:32:05 +08:00
using System.Collections.Generic;
2021-01-06 14:25:53 +08:00
using JetBrains.Annotations;
2016-11-11 06:40:42 +08:00
using osu.Framework.Allocation;
2018-04-30 01:15:09 +08:00
using osu.Framework.Audio;
using osu.Framework.Audio.Sample;
2019-02-21 18:04:31 +08:00
using osu.Framework.Bindables;
2018-04-30 01:15:09 +08:00
using osu.Framework.Graphics;
2017-02-17 17:59:30 +08:00
using osu.Framework.Screens;
2016-10-28 18:55:48 +08:00
using osu.Game.Beatmaps;
using osu.Game.Overlays;
2017-07-26 12:22:46 +08:00
using osu.Game.Rulesets;
using osu.Game.Rulesets.Mods;
using osu.Game.Screens.Menu;
using osu.Game.Users;
2018-04-13 17:19:50 +08:00
2016-11-14 16:23:33 +08:00
namespace osu.Game.Screens
2016-10-05 15:35:10 +08:00
{
public abstract class OsuScreen : Screen, IOsuScreen, IHasDescription
2016-10-05 15:35:10 +08:00
{
2019-01-25 13:10:59 +08:00
/// <summary>
/// The amount of negative padding that should be applied to game background content which touches both the left and right sides of the screen.
2020-05-05 09:26:12 +08:00
/// This allows for the game content to be pushed by the options/notification overlays without causing black areas to appear.
2019-01-25 13:10:59 +08:00
/// </summary>
public const float HORIZONTAL_OVERFLOW_PADDING = 50;
2018-05-28 12:02:06 +08:00
/// <summary>
/// A user-facing title for this screen.
/// </summary>
public virtual string Title => GetType().Name;
2018-05-28 12:02:06 +08:00
public string Description => Title;
2019-06-25 15:55:49 +08:00
public virtual bool AllowBackButton => true;
public virtual bool AllowExternalScreenChange => false;
public virtual bool HideOverlaysOnEnter => false;
public virtual bool HideMenuCursorOnNonMouseInput => false;
/// <summary>
2020-09-03 02:55:26 +08:00
/// The initial overlay activation mode to use when this screen is entered for the first time.
/// </summary>
protected virtual OverlayActivation InitialOverlayActivationMode => OverlayActivation.All;
2018-04-13 17:19:50 +08:00
public readonly Bindable<OverlayActivation> OverlayActivationMode;
IBindable<OverlayActivation> IOsuScreen.OverlayActivationMode => OverlayActivationMode;
public virtual bool CursorVisible => true;
2018-04-13 17:19:50 +08:00
protected new OsuGameBase Game => base.Game as OsuGameBase;
2018-04-13 17:19:50 +08:00
/// <summary>
2020-11-08 21:39:56 +08:00
/// The <see cref="UserActivity"/> to set the user's activity automatically to when this screen is entered.
/// <para>This <see cref="Activity"/> will be automatically set to <see cref="InitialActivity"/> for this screen on entering for the first time
/// unless <see cref="Activity"/> is manually set before.</para>
/// </summary>
protected virtual UserActivity InitialActivity => null;
/// <summary>
/// The current <see cref="UserActivity"/> for this screen.
/// </summary>
2020-11-09 20:39:50 +08:00
protected readonly Bindable<UserActivity> Activity = new Bindable<UserActivity>();
2020-11-08 19:29:52 +08:00
IBindable<UserActivity> IOsuScreen.Activity => Activity;
2019-02-01 14:42:15 +08:00
/// <summary>
/// Whether to disallow changes to game-wise Beatmap/Ruleset bindables for this screen (and all children).
2019-02-01 14:42:15 +08:00
/// </summary>
public virtual bool DisallowExternalBeatmapRulesetChanges => false;
2021-01-19 16:11:40 +08:00
private Sample sampleExit;
2018-04-13 17:19:50 +08:00
protected virtual bool PlayExitSound => true;
2019-01-23 19:52:00 +08:00
public virtual float BackgroundParallaxAmount => 1;
2018-04-13 17:19:50 +08:00
[Resolved]
private MusicController musicController { get; set; }
public virtual bool? AllowTrackAdjustments => null;
2019-12-13 19:06:12 +08:00
public Bindable<WorkingBeatmap> Beatmap { get; private set; }
2019-02-02 16:11:25 +08:00
public Bindable<RulesetInfo> Ruleset { get; private set; }
2018-04-13 17:19:50 +08:00
public Bindable<IReadOnlyList<Mod>> Mods { get; private set; }
2018-04-13 17:19:50 +08:00
private OsuScreenDependencies screenDependencies;
private bool? trackAdjustmentStateAtSuspend;
internal void CreateLeasedDependencies(IReadOnlyDependencyContainer dependencies) => createDependencies(dependencies);
2019-02-02 16:11:25 +08:00
protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
{
if (screenDependencies == null)
{
if (DisallowExternalBeatmapRulesetChanges)
throw new InvalidOperationException($"Screens that specify {nameof(DisallowExternalBeatmapRulesetChanges)} must be pushed immediately.");
createDependencies(parent);
}
return base.CreateChildDependencies(screenDependencies);
}
private void createDependencies(IReadOnlyDependencyContainer dependencies)
{
screenDependencies = new OsuScreenDependencies(DisallowExternalBeatmapRulesetChanges, dependencies);
2019-02-01 14:42:15 +08:00
Beatmap = screenDependencies.Beatmap;
Ruleset = screenDependencies.Ruleset;
2019-04-10 11:03:57 +08:00
Mods = screenDependencies.Mods;
2019-02-02 16:11:25 +08:00
}
2018-04-13 17:19:50 +08:00
/// <summary>
/// The background created and owned by this screen. May be null if the background didn't change.
/// </summary>
2021-01-06 14:25:53 +08:00
[CanBeNull]
private BackgroundScreen ownedBackground;
2021-01-06 14:25:53 +08:00
[CanBeNull]
private BackgroundScreen background;
2019-01-31 10:00:33 +08:00
[Resolved(canBeNull: true)]
[CanBeNull]
private BackgroundScreenStack backgroundStack { get; set; }
2019-01-31 10:00:33 +08:00
[Resolved(canBeNull: true)]
private OsuLogo logo { get; set; }
2019-01-23 19:52:00 +08:00
protected OsuScreen()
{
Anchor = Anchor.Centre;
Origin = Anchor.Centre;
OverlayActivationMode = new Bindable<OverlayActivation>(InitialOverlayActivationMode);
2019-01-23 19:52:00 +08:00
}
[BackgroundDependencyLoader(true)]
2022-01-15 08:06:39 +08:00
private void load(AudioManager audio)
{
sampleExit = audio.Samples.Get(@"UI/screen-back");
}
2020-11-08 19:53:19 +08:00
protected override void LoadComplete()
{
base.LoadComplete();
Activity.Value ??= InitialActivity;
2016-10-28 18:55:48 +08:00
}
2018-04-13 17:19:50 +08:00
/// <summary>
/// Apply arbitrary changes to the current background screen in a thread safe manner.
/// </summary>
/// <param name="action">The operation to perform.</param>
public void ApplyToBackground(Action<BackgroundScreen> action)
{
if (backgroundStack == null)
throw new InvalidOperationException("Attempted to apply to background without a background stack being available.");
if (background == null)
throw new InvalidOperationException("Attempted to apply to background before screen is pushed.");
background.ApplyToBackground(action);
}
public override void OnResuming(ScreenTransitionEvent e)
{
applyArrivingDefaults(true);
2018-04-13 17:19:50 +08:00
// it's feasible to resume to a screen if the target screen never loaded successfully.
// in such a case there's no need to restore this value.
if (trackAdjustmentStateAtSuspend != null)
musicController.AllowTrackAdjustments = trackAdjustmentStateAtSuspend.Value;
base.OnResuming(e);
}
2018-04-13 17:19:50 +08:00
public override void OnSuspending(ScreenTransitionEvent e)
{
base.OnSuspending(e);
trackAdjustmentStateAtSuspend = musicController.AllowTrackAdjustments;
2017-11-08 15:34:03 +08:00
onSuspendingLogo();
}
2018-04-13 17:19:50 +08:00
public override void OnEntering(ScreenTransitionEvent e)
2016-10-05 15:35:10 +08:00
{
applyArrivingDefaults(false);
2018-04-13 17:19:50 +08:00
if (AllowTrackAdjustments != null)
musicController.AllowTrackAdjustments = AllowTrackAdjustments.Value;
if (backgroundStack?.Push(ownedBackground = CreateBackground()) != true)
{
// If the constructed instance was not actually pushed to the background stack, we don't want to track it unnecessarily.
ownedBackground?.Dispose();
ownedBackground = null;
}
background = backgroundStack?.CurrentScreen as BackgroundScreen;
base.OnEntering(e);
2016-10-05 15:35:10 +08:00
}
2018-04-13 17:19:50 +08:00
public override bool OnExiting(ScreenExitEvent e)
2016-10-05 15:35:10 +08:00
{
if (ValidForResume && PlayExitSound)
sampleExit?.Play();
if (ValidForResume && logo != null)
2017-11-08 15:34:03 +08:00
onExitingLogo();
2018-04-13 17:19:50 +08:00
if (base.OnExiting(e))
return true;
2018-04-13 17:19:50 +08:00
if (ownedBackground != null && backgroundStack?.CurrentScreen == ownedBackground)
backgroundStack?.Exit();
return false;
2016-10-05 15:35:10 +08:00
}
2018-04-13 17:19:50 +08:00
2017-11-08 15:34:03 +08:00
/// <summary>
/// Fired when this screen was entered or resumed and the logo state is required to be adjusted.
/// </summary>
2017-11-09 16:38:20 +08:00
protected virtual void LogoArriving(OsuLogo logo, bool resuming)
{
2019-01-25 20:02:35 +08:00
ApplyLogoArrivingDefaults(logo);
}
2018-04-13 17:19:50 +08:00
private void applyArrivingDefaults(bool isResuming)
{
2019-01-31 10:00:33 +08:00
logo?.AppendAnimatingAction(() =>
{
2019-01-23 19:52:00 +08:00
if (this.IsCurrentScreen()) LogoArriving(logo, isResuming);
}, true);
}
2019-01-25 20:02:35 +08:00
/// <summary>
/// Applies default animations to an arriving logo.
/// Todo: This should not exist.
/// </summary>
/// <param name="logo">The logo to apply animations to.</param>
public static void ApplyLogoArrivingDefaults(OsuLogo logo)
{
logo.Action = null;
logo.FadeOut(300, Easing.OutQuint);
logo.Anchor = Anchor.TopLeft;
logo.Origin = Anchor.Centre;
logo.RelativePositionAxes = Axes.Both;
2019-01-25 20:02:35 +08:00
logo.Triangles = true;
logo.Ripple = true;
}
2018-04-13 17:19:50 +08:00
2017-11-08 15:34:03 +08:00
private void onExitingLogo()
{
2019-01-31 10:00:33 +08:00
logo?.AppendAnimatingAction(() => LogoExiting(logo), false);
}
2018-04-13 17:19:50 +08:00
2017-11-08 15:34:03 +08:00
/// <summary>
/// Fired when this screen was exited to add any outwards transition to the logo.
/// </summary>
2017-11-09 16:38:20 +08:00
protected virtual void LogoExiting(OsuLogo logo)
{
}
2018-04-13 17:19:50 +08:00
2017-11-08 15:34:03 +08:00
private void onSuspendingLogo()
{
2019-01-31 10:00:33 +08:00
logo?.AppendAnimatingAction(() => LogoSuspending(logo), false);
}
2018-04-13 17:19:50 +08:00
2017-11-08 15:34:03 +08:00
/// <summary>
/// Fired when this screen was suspended to add any outwards transition to the logo.
/// </summary>
2017-11-09 16:38:20 +08:00
protected virtual void LogoSuspending(OsuLogo logo)
{
}
/// <summary>
/// Override to create a BackgroundMode for the current screen.
/// Note that the instance created may not be the used instance if it matches the BackgroundMode equality clause.
/// </summary>
protected virtual BackgroundScreen CreateBackground() => null;
2020-07-14 14:59:20 +08:00
public virtual bool OnBackButton() => false;
2016-10-05 15:35:10 +08:00
}
}