1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-17 16:52:57 +08:00
osu-lazer/osu.Game/OsuGame.cs

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

1627 lines
66 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;
using System.Collections.Generic;
2019-02-28 16:17:51 +08:00
using System.Diagnostics;
using System.IO;
2017-02-05 05:03:39 +08:00
using System.Linq;
using System.Reflection;
2017-12-25 17:22:58 +08:00
using System.Threading;
2017-02-24 17:10:37 +08:00
using System.Threading.Tasks;
using Humanizer;
2020-05-09 18:13:18 +08:00
using JetBrains.Annotations;
using osu.Framework;
using osu.Framework.Allocation;
using osu.Framework.Audio;
2019-02-21 18:04:31 +08:00
using osu.Framework.Bindables;
using osu.Framework.Configuration;
using osu.Framework.Extensions;
using osu.Framework.Extensions.IEnumerableExtensions;
using osu.Framework.Extensions.TypeExtensions;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
2024-05-16 12:20:55 +08:00
using osu.Framework.Graphics.Cursor;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Input;
2017-08-11 15:11:46 +08:00
using osu.Framework.Input.Bindings;
2021-09-16 17:26:12 +08:00
using osu.Framework.Input.Events;
using osu.Framework.Input.Handlers.Tablet;
using osu.Framework.Localisation;
using osu.Framework.Logging;
using osu.Framework.Platform;
using osu.Framework.Screens;
using osu.Framework.Threading;
using osu.Game.Beatmaps;
2020-09-05 02:52:07 +08:00
using osu.Game.Collections;
using osu.Game.Configuration;
using osu.Game.Database;
using osu.Game.Extensions;
2017-03-04 18:02:36 +08:00
using osu.Game.Graphics;
2019-01-04 12:29:37 +08:00
using osu.Game.Graphics.Containers;
2019-06-25 15:55:49 +08:00
using osu.Game.Graphics.UserInterface;
using osu.Game.Input;
2017-08-11 15:11:46 +08:00
using osu.Game.Input.Bindings;
using osu.Game.IO;
using osu.Game.Localisation;
2022-06-21 02:04:21 +08:00
using osu.Game.Online;
using osu.Game.Online.Chat;
using osu.Game.Online.Rooms;
using osu.Game.Overlays;
using osu.Game.Overlays.BeatmapListing;
using osu.Game.Overlays.Mods;
using osu.Game.Overlays.Music;
using osu.Game.Overlays.Notifications;
using osu.Game.Overlays.OSD;
2023-01-26 17:21:04 +08:00
using osu.Game.Overlays.SkinEditor;
using osu.Game.Overlays.Toolbar;
2018-03-04 02:08:35 +08:00
using osu.Game.Overlays.Volume;
using osu.Game.Rulesets.Mods;
2018-11-28 15:12:57 +08:00
using osu.Game.Scoring;
using osu.Game.Screens;
using osu.Game.Screens.Edit;
2024-05-16 12:20:55 +08:00
using osu.Game.Screens.Footer;
using osu.Game.Screens.Menu;
using osu.Game.Screens.OnlinePlay.DailyChallenge;
using osu.Game.Screens.OnlinePlay.Multiplayer;
using osu.Game.Screens.Play;
using osu.Game.Screens.Ranking;
using osu.Game.Screens.Select;
using osu.Game.Skinning;
using osu.Game.Updater;
using osu.Game.Users;
using osu.Game.Utils;
using osuTK.Graphics;
2022-05-11 11:55:15 +08:00
using Sentry;
2018-04-13 17:19:50 +08:00
2016-08-26 11:28:23 +08:00
namespace osu.Game
{
/// <summary>
/// The full osu! experience. Builds on top of <see cref="OsuGameBase"/> to add menus and binding logic
/// for initial components that are generally retrieved via DI.
/// </summary>
2022-10-12 22:50:31 +08:00
[Cached(typeof(OsuGame))]
2022-06-21 02:04:21 +08:00
public partial class OsuGame : OsuGameBase, IKeyBindingHandler<GlobalAction>, ILocalUserPlayInfo, IPerformFromScreenRunner, IOverlayManager, ILinkHandler
2016-08-26 11:28:23 +08:00
{
#if DEBUG
2024-07-12 20:25:21 +08:00
// Different port allows running release and debug builds alongside each other.
public const int IPC_PORT = 44824;
#else
public const int IPC_PORT = 44823;
#endif
/// <summary>
/// The amount of global offset to apply when a left/right anchored overlay is displayed (ie. settings or notifications).
/// </summary>
protected const float SIDE_OVERLAY_OFFSET_RATIO = 0.05f;
2021-08-07 03:36:40 +08:00
/// <summary>
/// A common shear factor applied to most components of the game.
/// </summary>
public const float SHEAR = 0.2f;
public Toolbar Toolbar { get; private set; }
2018-04-13 17:19:50 +08:00
private ChatOverlay chatOverlay;
private ChannelManager channelManager;
2018-04-13 17:19:50 +08:00
[NotNull]
2021-08-07 03:36:40 +08:00
protected readonly NotificationOverlay Notifications = new NotificationOverlay();
2018-04-13 17:19:50 +08:00
private BeatmapListingOverlay beatmapListing;
private DashboardOverlay dashboard;
2018-04-13 17:19:50 +08:00
2020-07-16 19:48:40 +08:00
private NewsOverlay news;
2018-04-13 17:19:50 +08:00
2017-06-15 17:03:33 +08:00
private UserProfileOverlay userProfile;
2018-04-13 17:19:50 +08:00
private BeatmapSetOverlay beatmapSetOverlay;
2018-04-13 17:19:50 +08:00
2021-04-22 17:16:12 +08:00
private WikiOverlay wikiOverlay;
private ChangelogOverlay changelogOverlay;
private SkinEditorOverlay skinEditor;
private Container overlayContent;
private Container rightFloatingOverlayContent;
private Container leftFloatingOverlayContent;
private Container topMostOverlayContent;
private Container footerBasedOverlayContent;
protected ScalingContainer ScreenContainer { get; private set; }
protected Container ScreenOffsetContainer { get; private set; }
private Container overlayOffsetContainer;
private OnScreenDisplay onScreenDisplay;
[Resolved]
private FrameworkConfigManager frameworkConfig { get; set; }
[Cached]
private readonly DifficultyRecommender difficultyRecommender = new DifficultyRecommender();
2021-05-09 23:12:58 +08:00
[Cached]
2021-11-25 16:12:15 +08:00
private readonly LegacyImportManager legacyImportManager = new LegacyImportManager();
2021-05-09 23:12:58 +08:00
2018-10-02 09:12:07 +08:00
[Cached]
private readonly ScreenshotManager screenshotManager = new ScreenshotManager();
2019-11-12 22:08:16 +08:00
protected SentryLogger SentryLogger;
2018-08-03 18:25:55 +08:00
public virtual StableStorage GetStorageForStableInstall() => null;
2018-04-13 17:19:50 +08:00
private float toolbarOffset => (Toolbar?.Position.Y ?? 0) + (Toolbar?.DrawHeight ?? 0);
2018-04-13 17:19:50 +08:00
private IdleTracker idleTracker;
2022-10-12 22:50:31 +08:00
/// <summary>
/// Whether the user is currently in an idle state.
/// </summary>
public IBindable<bool> IsIdle => idleTracker.IsIdle;
2020-09-03 02:55:26 +08:00
/// <summary>
/// Whether overlays should be able to be opened game-wide. Value is sourced from the current active screen.
/// </summary>
2020-08-28 02:07:24 +08:00
public readonly IBindable<OverlayActivation> OverlayActivationMode = new Bindable<OverlayActivation>();
2018-04-13 17:19:50 +08:00
/// <summary>
2020-10-07 13:44:49 +08:00
/// Whether the local user is currently interacting with the game in a way that should not be interrupted.
/// </summary>
2020-10-08 17:25:40 +08:00
/// <remarks>
/// This is exclusively managed by <see cref="Player"/>. If other components are mutating this state, a more
/// resilient method should be used to ensure correct state.
/// </remarks>
public Bindable<bool> LocalUserPlaying = new BindableBool();
2018-04-13 17:19:50 +08:00
protected OsuScreenStack ScreenStack;
2019-07-31 18:47:41 +08:00
protected BackButton BackButton;
2024-05-16 12:20:55 +08:00
protected ScreenFooter ScreenFooter;
2020-05-12 11:49:35 +08:00
protected SettingsOverlay Settings;
2019-07-31 18:47:41 +08:00
2022-06-15 08:34:08 +08:00
protected FirstRunSetupOverlay FirstRunOverlay { get; private set; }
2022-04-06 16:42:10 +08:00
2022-07-20 20:05:20 +08:00
private FPSCounter fpsCounter;
2018-03-04 02:08:35 +08:00
private VolumeOverlay volume;
2019-01-23 19:52:00 +08:00
private OsuLogo osuLogo;
private MainMenu menuScreen;
private VersionManager versionManager;
2020-05-09 18:13:18 +08:00
[CanBeNull]
private IntroScreen introScreen;
2018-04-13 17:19:50 +08:00
private Bindable<string> configRuleset;
2018-04-13 17:19:50 +08:00
private Bindable<bool> applySafeAreaConsiderations;
private Bindable<float> uiScale;
private Bindable<string> configSkin;
2018-04-13 17:19:50 +08:00
private readonly string[] args;
2018-04-13 17:19:50 +08:00
private readonly List<OsuFocusedOverlayContainer> focusedOverlays = new List<OsuFocusedOverlayContainer>();
private readonly List<OverlayContainer> externalOverlays = new List<OverlayContainer>();
2018-06-06 15:17:51 +08:00
private readonly List<OverlayContainer> visibleBlockingOverlays = new List<OverlayContainer>();
2018-04-13 17:19:50 +08:00
public OsuGame(string[] args = null)
{
this.args = args;
2022-09-22 18:17:01 +08:00
forwardGeneralLogsToNotifications();
forwardTabletLogsToNotifications();
2018-08-03 18:25:55 +08:00
2019-11-12 22:08:16 +08:00
SentryLogger = new SentryLogger(this);
}
2018-04-13 17:19:50 +08:00
#region IOverlayManager
IBindable<OverlayActivation> IOverlayManager.OverlayActivationMode => OverlayActivationMode;
private void updateBlockingOverlayFade() =>
ScreenContainer.FadeColour(visibleBlockingOverlays.Any() ? OsuColour.Gray(0.5f) : Color4.White, 500, Easing.OutQuint);
IDisposable IOverlayManager.RegisterBlockingOverlay(OverlayContainer overlayContainer)
{
if (overlayContainer.Parent != null)
throw new ArgumentException($@"Overlays registered via {nameof(IOverlayManager.RegisterBlockingOverlay)} should not be added to the scene graph.");
if (externalOverlays.Contains(overlayContainer))
throw new ArgumentException($@"{overlayContainer} has already been registered via {nameof(IOverlayManager.RegisterBlockingOverlay)} once.");
externalOverlays.Add(overlayContainer);
if (overlayContainer is ShearedOverlayContainer)
footerBasedOverlayContent.Add(overlayContainer);
else
overlayContent.Add(overlayContainer);
if (overlayContainer is OsuFocusedOverlayContainer focusedOverlayContainer)
focusedOverlays.Add(focusedOverlayContainer);
return new InvokeOnDisposal(() => unregisterBlockingOverlay(overlayContainer));
}
void IOverlayManager.ShowBlockingOverlay(OverlayContainer overlay)
{
if (!visibleBlockingOverlays.Contains(overlay))
visibleBlockingOverlays.Add(overlay);
updateBlockingOverlayFade();
}
void IOverlayManager.HideBlockingOverlay(OverlayContainer overlay) => Schedule(() =>
{
2019-03-01 12:29:02 +08:00
visibleBlockingOverlays.Remove(overlay);
updateBlockingOverlayFade();
});
/// <summary>
/// Unregisters a blocking <see cref="OverlayContainer"/> that was not created by <see cref="OsuGame"/> itself.
/// </summary>
2022-06-28 00:19:20 +08:00
private void unregisterBlockingOverlay(OverlayContainer overlayContainer) => Schedule(() =>
{
externalOverlays.Remove(overlayContainer);
if (overlayContainer is OsuFocusedOverlayContainer focusedOverlayContainer)
focusedOverlays.Remove(focusedOverlayContainer);
overlayContainer.Expire();
2022-06-28 00:19:20 +08:00
});
#endregion
2018-06-06 15:17:51 +08:00
/// <summary>
/// Close all game-wide overlays.
/// </summary>
2019-11-08 22:04:18 +08:00
/// <param name="hideToolbar">Whether the toolbar should also be hidden.</param>
public void CloseAllOverlays(bool hideToolbar = true)
2018-06-06 15:17:51 +08:00
{
2022-06-28 00:19:20 +08:00
foreach (var overlay in focusedOverlays)
overlay.Hide();
2019-11-08 22:04:18 +08:00
if (hideToolbar) Toolbar.Hide();
2018-06-06 15:17:51 +08:00
}
protected override UserInputManager CreateUserInputManager()
{
var userInputManager = base.CreateUserInputManager();
(userInputManager as OsuUserInputManager)?.LocalUserPlaying.BindTo(LocalUserPlaying);
return userInputManager;
}
private DependencyContainer dependencies;
2018-04-13 17:19:50 +08:00
2018-07-11 16:07:14 +08:00
protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
2018-04-13 17:19:50 +08:00
private readonly List<string> dragDropFiles = new List<string>();
private ScheduledDelegate dragDropImportSchedule;
public override void SetHost(GameHost host)
{
base.SetHost(host);
if (host.Window != null)
{
host.Window.DragDrop += path =>
{
// on macOS/iOS, URL associations are handled via SDL_DROPFILE events.
if (path.StartsWith(OSU_PROTOCOL, StringComparison.Ordinal))
{
HandleLink(path);
return;
}
lock (dragDropFiles)
{
dragDropFiles.Add(path);
Logger.Log($@"Adding ""{Path.GetFileName(path)}"" for import");
// File drag drop operations can potentially trigger hundreds or thousands of these calls on some platforms.
// In order to avoid spawning multiple import tasks for a single drop operation, debounce a touch.
dragDropImportSchedule?.Cancel();
dragDropImportSchedule = Scheduler.AddDelayed(handlePendingDragDropImports, 100);
}
};
}
}
private void handlePendingDragDropImports()
{
lock (dragDropFiles)
{
Logger.Log($"Handling batch import of {dragDropFiles.Count} files");
string[] paths = dragDropFiles.ToArray();
dragDropFiles.Clear();
Task.Factory.StartNew(() => Import(paths), TaskCreationOptions.LongRunning);
}
}
[BackgroundDependencyLoader]
2020-02-14 21:14:00 +08:00
private void load()
2016-08-26 11:28:23 +08:00
{
SentryLogger.AttachUser(API.LocalUser);
dependencies.Cache(osuLogo = new OsuLogo { Alpha = 0 });
2019-01-23 19:52:00 +08:00
2018-02-22 15:29:05 +08:00
// bind config int to database RulesetInfo
configRuleset = LocalConfig.GetBindable<string>(OsuSetting.Ruleset);
uiScale = LocalConfig.GetBindable<float>(OsuSetting.UIScale);
var preferredRuleset = RulesetStore.GetRuleset(configRuleset.Value);
try
{
Ruleset.Value = preferredRuleset ?? RulesetStore.AvailableRulesets.First();
}
catch (Exception e)
{
// on startup, a ruleset may be selected which has compatibility issues.
Logger.Error(e, $@"Failed to switch to preferred ruleset {preferredRuleset}.");
Ruleset.Value = RulesetStore.AvailableRulesets.First();
}
Ruleset.ValueChanged += r => configRuleset.Value = r.NewValue.ShortName;
2018-04-13 17:19:50 +08:00
configSkin = LocalConfig.GetBindable<string>(OsuSetting.Skin);
// Transfer skin from config to realm instance once on startup.
SkinManager.SetSkinFromConfiguration(configSkin.Value);
// Transfer any runtime changes back to configuration file.
SkinManager.CurrentSkinInfo.ValueChanged += skin => configSkin.Value = skin.NewValue.ID.ToString();
2018-04-13 17:19:50 +08:00
LocalUserPlaying.BindValueChanged(p =>
{
BeatmapManager.PauseImports = p.NewValue;
SkinManager.PauseImports = p.NewValue;
ScoreManager.PauseImports = p.NewValue;
}, true);
2023-01-09 17:54:11 +08:00
IsActive.BindValueChanged(active => updateActiveState(active.NewValue), true);
Audio.AddAdjustment(AdjustableProperty.Volume, inactiveVolumeFade);
SelectedMods.BindValueChanged(modsChanged);
Beatmap.BindValueChanged(beatmapChanged, true);
applySafeAreaConsiderations = LocalConfig.GetBindable<bool>(OsuSetting.SafeAreaConsiderations);
applySafeAreaConsiderations.BindValueChanged(apply => SafeAreaContainer.SafeAreaOverrideEdges = apply.NewValue ? SafeAreaOverrideEdges : Edges.All, true);
}
2018-04-13 17:19:50 +08:00
2018-11-02 04:52:07 +08:00
private ExternalLinkOpener externalLinkOpener;
2019-01-04 12:29:37 +08:00
/// <summary>
/// Handle an arbitrary URL. Displays via in-game overlays where possible.
/// This can be called from a non-thread-safe non-game-loaded state.
/// </summary>
/// <param name="url">The URL to load.</param>
2019-11-03 12:16:54 +08:00
public void HandleLink(string url) => HandleLink(MessageFormatter.GetLinkDetails(url));
/// <summary>
/// Handle a specific <see cref="LinkDetails"/>.
/// This can be called from a non-thread-safe non-game-loaded state.
/// </summary>
/// <param name="link">The link to load.</param>
2019-11-03 12:16:54 +08:00
public void HandleLink(LinkDetails link) => Schedule(() =>
{
2022-12-19 15:41:04 +08:00
string argString = link.Argument.ToString() ?? string.Empty;
switch (link.Action)
{
case LinkAction.OpenBeatmap:
// TODO: proper query params handling
if (int.TryParse(argString.Contains('?') ? argString.Split('?')[0] : argString, out int beatmapId))
ShowBeatmap(beatmapId);
break;
case LinkAction.OpenBeatmapSet:
if (int.TryParse(argString, out int setId))
ShowBeatmapSet(setId);
break;
case LinkAction.OpenChannel:
ShowChannel(argString);
break;
2020-01-31 06:41:50 +08:00
case LinkAction.SearchBeatmapSet:
if (link.Argument is RomanisableString romanisable)
SearchBeatmapSet(romanisable.GetPreferred(Localisation.CurrentParameters.Value.PreferOriginalScript));
else
SearchBeatmapSet(argString);
2020-01-30 12:30:25 +08:00
break;
case LinkAction.FilterBeatmapSetGenre:
FilterBeatmapSetGenre((SearchGenre)link.Argument);
break;
case LinkAction.FilterBeatmapSetLanguage:
FilterBeatmapSetLanguage((SearchLanguage)link.Argument);
break;
case LinkAction.OpenEditorTimestamp:
2023-11-12 22:09:15 +08:00
HandleTimestamp(argString);
break;
case LinkAction.JoinMultiplayerMatch:
case LinkAction.Spectate:
2021-08-07 03:36:40 +08:00
waitForReady(() => Notifications, _ => Notifications.Post(new SimpleNotification
{
2023-06-28 02:56:35 +08:00
Text = NotificationsStrings.LinkTypeNotSupported,
Icon = FontAwesome.Solid.LifeRing,
}));
break;
case LinkAction.External:
OpenUrlExternally(argString);
break;
case LinkAction.OpenUserProfile:
ShowUser((IUser)link.Argument);
break;
2021-05-17 01:43:59 +08:00
case LinkAction.OpenWiki:
ShowWiki(argString);
2021-05-17 01:43:59 +08:00
break;
case LinkAction.OpenChangelog:
if (string.IsNullOrEmpty(argString))
ShowChangelogListing();
else
{
string[] changelogArgs = argString.Split("/");
ShowChangelogBuild(changelogArgs[0], changelogArgs[1]);
}
break;
default:
throw new NotImplementedException($"This {nameof(LinkAction)} ({link.Action.ToString()}) is missing an associated action.");
}
2019-11-03 12:16:54 +08:00
});
public void CopyUrlToClipboard(string url) => waitForReady(() => onScreenDisplay, _ =>
{
dependencies.Get<Clipboard>().SetText(url);
onScreenDisplay.Display(new CopyUrlToast());
});
public void OpenUrlExternally(string url, bool forceBypassExternalUrlWarning = false) => waitForReady(() => externalLinkOpener, _ =>
2018-12-06 11:17:08 +08:00
{
bool isTrustedDomain;
if (url.StartsWith('/'))
{
url = $"{API.WebsiteRootUrl}{url}";
isTrustedDomain = true;
}
else
{
2024-05-31 14:38:26 +08:00
isTrustedDomain = url.StartsWith(API.WebsiteRootUrl, StringComparison.Ordinal);
}
2018-12-06 11:17:08 +08:00
if (!url.CheckIsValidUrl())
{
Notifications.Post(new SimpleErrorNotification
{
2023-06-28 02:56:35 +08:00
Text = NotificationsStrings.UnsupportedOrDangerousUrlProtocol(url),
});
return;
}
externalLinkOpener.OpenUrlExternally(url, forceBypassExternalUrlWarning || isTrustedDomain);
});
/// <summary>
/// Open a specific channel in chat.
/// </summary>
/// <param name="channel">The channel to display.</param>
public void ShowChannel(string channel) => waitForReady(() => channelManager, _ =>
{
try
{
channelManager.OpenChannel(channel);
}
catch (ChannelNotFoundException)
{
Logger.Log($"The requested channel \"{channel}\" does not exist");
}
});
2018-11-02 04:52:07 +08:00
2018-01-17 19:32:26 +08:00
/// <summary>
/// Show a beatmap set as an overlay.
/// </summary>
/// <param name="setId">The set to display.</param>
public void ShowBeatmapSet(int setId) => waitForReady(() => beatmapSetOverlay, _ => beatmapSetOverlay.FetchAndShowBeatmapSet(setId));
2018-04-13 17:19:50 +08:00
2019-02-25 11:58:58 +08:00
/// <summary>
/// Show a user's profile as an overlay.
/// </summary>
/// <param name="user">The user to display.</param>
public void ShowUser(IUser user) => waitForReady(() => userProfile, _ => userProfile.ShowUser(user));
2019-02-25 11:58:58 +08:00
/// <summary>
/// Show a beatmap's set as an overlay, displaying the given beatmap.
/// </summary>
/// <param name="beatmapId">The beatmap to show.</param>
public void ShowBeatmap(int beatmapId) => waitForReady(() => beatmapSetOverlay, _ => beatmapSetOverlay.FetchAndShowBeatmap(beatmapId));
2019-02-25 11:58:58 +08:00
2020-01-30 12:30:25 +08:00
/// <summary>
2021-07-03 21:22:03 +08:00
/// Shows the beatmap listing overlay, with the given <paramref name="query"/> in the search box.
2020-01-30 12:30:25 +08:00
/// </summary>
2020-01-31 06:41:50 +08:00
/// <param name="query">The query to search for.</param>
public void SearchBeatmapSet(string query) => waitForReady(() => beatmapListing, _ => beatmapListing.ShowWithSearch(query));
public void FilterBeatmapSetGenre(SearchGenre genre) => waitForReady(() => beatmapListing, _ => beatmapListing.ShowWithGenreFilter(genre));
public void FilterBeatmapSetLanguage(SearchLanguage language) => waitForReady(() => beatmapListing, _ => beatmapListing.ShowWithLanguageFilter(language));
2021-05-17 01:43:59 +08:00
/// <summary>
/// Show a wiki's page as an overlay
/// </summary>
/// <param name="path">The wiki page to show</param>
public void ShowWiki(string path) => waitForReady(() => wikiOverlay, _ => wikiOverlay.ShowPage(path));
2020-01-30 12:30:25 +08:00
/// <summary>
/// Show changelog listing overlay
/// </summary>
public void ShowChangelogListing() => waitForReady(() => changelogOverlay, _ => changelogOverlay.ShowListing());
/// <summary>
/// Show changelog's build as an overlay
/// </summary>
/// <param name="updateStream">The update stream name</param>
/// <param name="version">The build version of the update stream</param>
public void ShowChangelogBuild(string updateStream, string version) => waitForReady(() => changelogOverlay, _ => changelogOverlay.ShowBuild(updateStream, version));
/// <summary>
2023-11-20 20:02:12 +08:00
/// Seeks to the provided <paramref name="timestamp"/> if the editor is currently open.
/// Can also select objects as indicated by the <paramref name="timestamp"/> (depends on ruleset implementation).
/// </summary>
2023-11-12 22:09:15 +08:00
public void HandleTimestamp(string timestamp)
{
if (ScreenStack.CurrentScreen is not Editor editor)
{
Schedule(() => Notifications.Post(new SimpleErrorNotification
{
Icon = FontAwesome.Solid.ExclamationTriangle,
2023-11-21 14:08:15 +08:00
Text = EditorStrings.MustBeInEditorToHandleLinks
}));
return;
}
2024-06-18 18:33:12 +08:00
editor.HandleTimestamp(timestamp, notifyOnError: true);
}
/// <summary>
/// Present a skin select immediately.
/// </summary>
/// <param name="skin">The skin to select.</param>
public void PresentSkin(SkinInfo skin)
{
var databasedSkin = SkinManager.Query(s => s.ID == skin.ID);
if (databasedSkin == null)
{
Logger.Log("The requested skin could not be loaded.", LoggingTarget.Information);
return;
}
SkinManager.CurrentSkinInfo.Value = databasedSkin;
}
/// <summary>
/// Present a beatmap at song select immediately.
/// The user should have already requested this interactively.
/// </summary>
/// <param name="beatmap">The beatmap to select.</param>
2020-11-21 20:26:09 +08:00
/// <param name="difficultyCriteria">Optional predicate used to narrow the set of difficulties to select from when presenting.</param>
/// <remarks>
/// Among items satisfying the predicate, the order of preference is:
/// <list type="bullet">
/// <item>beatmap with recommended difficulty, as provided by <see cref="DifficultyRecommender"/>,</item>
/// <item>first beatmap from the current ruleset,</item>
/// <item>first beatmap from any ruleset.</item>
/// </list>
/// </remarks>
public void PresentBeatmap(IBeatmapSetInfo beatmap, Predicate<BeatmapInfo> difficultyCriteria = null)
{
Logger.Log($"Beginning {nameof(PresentBeatmap)} with beatmap {beatmap}");
Live<BeatmapSetInfo> databasedSet = null;
if (beatmap.OnlineID > 0)
databasedSet = BeatmapManager.QueryBeatmapSet(s => s.OnlineID == beatmap.OnlineID && !s.DeletePending);
if (beatmap is BeatmapSetInfo localBeatmap)
databasedSet ??= BeatmapManager.QueryBeatmapSet(s => s.Hash == localBeatmap.Hash && !s.DeletePending);
2019-02-25 11:58:58 +08:00
if (databasedSet == null)
2019-01-23 19:52:00 +08:00
{
2019-02-25 11:58:58 +08:00
Logger.Log("The requested beatmap could not be loaded.", LoggingTarget.Information);
2019-01-23 19:52:00 +08:00
return;
}
var detachedSet = databasedSet.PerformRead(s => s.Detach());
if (detachedSet.DeletePending)
{
Logger.Log("The requested beatmap has since been deleted.", LoggingTarget.Information);
return;
}
2020-01-30 22:34:04 +08:00
PerformFromScreen(screen =>
2018-07-13 20:08:41 +08:00
{
// Find beatmaps that match our predicate.
var beatmaps = detachedSet.Beatmaps.Where(b => difficultyCriteria?.Invoke(b) ?? true).ToList();
// Use all beatmaps if predicate matched nothing
if (beatmaps.Count == 0)
beatmaps = detachedSet.Beatmaps.ToList();
// Prefer recommended beatmap if recommendations are available, else fallback to a sane selection.
var selection = difficultyRecommender.GetRecommendedBeatmap(beatmaps)
?? beatmaps.FirstOrDefault(b => b.Ruleset.Equals(Ruleset.Value))
?? beatmaps.First();
if (screen is IHandlePresentBeatmap presentableScreen)
{
presentableScreen.PresentBeatmap(BeatmapManager.GetWorkingBeatmap(selection), selection.Ruleset);
}
else
{
// Don't change the local ruleset if the user is on another ruleset and is showing converted beatmaps at song select.
// Eventually we probably want to check whether conversion is actually possible for the current ruleset.
bool requiresRulesetSwitch = !selection.Ruleset.Equals(Ruleset.Value)
&& (selection.Ruleset.OnlineID > 0 || !LocalConfig.Get<bool>(OsuSetting.ShowConvertedBeatmaps));
if (requiresRulesetSwitch)
{
Ruleset.Value = selection.Ruleset;
Beatmap.Value = BeatmapManager.GetWorkingBeatmap(selection);
Logger.Log($"Completing {nameof(PresentBeatmap)} with beatmap {beatmap} ruleset {selection.Ruleset}");
}
else
{
Beatmap.Value = BeatmapManager.GetWorkingBeatmap(selection);
Logger.Log($"Completing {nameof(PresentBeatmap)} with beatmap {beatmap} (maintaining ruleset)");
}
}
}, validScreens: new[]
{
typeof(SongSelect), typeof(IHandlePresentBeatmap)
});
}
/// <summary>
/// Join a multiplayer match immediately.
/// </summary>
/// <param name="room">The room to join.</param>
/// <param name="password">The password to join the room, if any is given.</param>
public void PresentMultiplayerMatch(Room room, string password)
{
PerformFromScreen(screen =>
{
if (!(screen is Multiplayer multiplayer))
screen.Push(multiplayer = new Multiplayer());
multiplayer.Join(room, password);
});
// TODO: We should really be able to use `validScreens: new[] { typeof(Multiplayer) }` here
// but `PerformFromScreen` doesn't understand nested stacks.
}
/// <summary>
/// Present a score's replay immediately.
/// The user should have already requested this interactively.
/// </summary>
public void PresentScore(IScoreInfo score, ScorePresentType presentType = ScorePresentType.Results)
2017-03-04 18:02:36 +08:00
{
Logger.Log($"Beginning {nameof(PresentScore)} with score {score}");
var databasedScore = ScoreManager.GetScore(score);
2021-06-15 13:06:17 +08:00
if (databasedScore == null) return;
2019-04-01 11:16:05 +08:00
2018-11-30 17:31:54 +08:00
if (databasedScore.Replay == null)
{
Logger.Log("The loaded score has no replay data.", LoggingTarget.Information);
return;
}
2024-04-23 02:15:50 +08:00
var databasedBeatmap = BeatmapManager.QueryBeatmap(b => b.ID == databasedScore.ScoreInfo.BeatmapInfo.ID);
2019-04-01 11:16:05 +08:00
2018-11-30 17:31:54 +08:00
if (databasedBeatmap == null)
{
Logger.Log("Tried to load a score for a beatmap we don't have!", LoggingTarget.Information);
return;
}
// This should be able to be performed from song select always, but that is disabled for now
// due to the weird decoupled ruleset logic (which can cause a crash in certain filter scenarios).
//
// As a special case, if the beatmap and ruleset already match, allow immediately displaying the score from song select.
// This is guaranteed to not crash, and feels better from a user's perspective (ie. if they are clicking a score in the
// song select leaderboard).
// Similar exemptions are made here for daily challenge where it is guaranteed that beatmap and ruleset match.
// `OnlinePlayScreen` is excluded because when resuming back to it,
// `RoomSubScreen` changes the global beatmap to the next playlist item on resume,
// which may not match the score, and thus crash.
IEnumerable<Type> validScreens =
Beatmap.Value.BeatmapInfo.Equals(databasedBeatmap) && Ruleset.Value.Equals(databasedScore.ScoreInfo.Ruleset)
? new[] { typeof(SongSelect), typeof(DailyChallenge) }
: Array.Empty<Type>();
2020-01-30 22:34:04 +08:00
PerformFromScreen(screen =>
2019-02-25 11:58:58 +08:00
{
2022-10-04 17:21:29 +08:00
Logger.Log($"{nameof(PresentScore)} updating beatmap ({databasedBeatmap}) and ruleset ({databasedScore.ScoreInfo.Ruleset}) to match score");
// some screens (mostly online) disable the ruleset/beatmap bindable.
// attempting to set the ruleset/beatmap in that state will crash.
// however, the `validScreens` pre-check above should ensure that we actually never come from one of those screens
// while simultaneously having mismatched ruleset/beatmap.
// therefore this is just a safety against touching the possibly-disabled bindables if we don't actually have to touch them.
// if it ever fails, then this probably *should* crash anyhow (so that we can fix it).
if (!Ruleset.Value.Equals(databasedScore.ScoreInfo.Ruleset))
Ruleset.Value = databasedScore.ScoreInfo.Ruleset;
if (!Beatmap.Value.BeatmapInfo.Equals(databasedBeatmap))
Beatmap.Value = BeatmapManager.GetWorkingBeatmap(databasedBeatmap);
2019-02-25 11:58:58 +08:00
switch (presentType)
{
case ScorePresentType.Gameplay:
screen.Push(new ReplayPlayerLoader(databasedScore));
break;
case ScorePresentType.Results:
screen.Push(new SoloResultsScreen(databasedScore.ScoreInfo));
break;
}
}, validScreens: validScreens);
2019-02-25 11:58:58 +08:00
}
public override Task Import(ImportTask[] imports, ImportParameters parameters = default)
{
// encapsulate task as we don't want to begin the import process until in a ready state.
// ReSharper disable once AsyncVoidLambda
// TODO: This is bad because `new Task` doesn't have a Func<Task?> override.
// Only used for android imports and a bit of a mess. Probably needs rethinking overall.
var importTask = new Task(async () => await base.Import(imports, parameters).ConfigureAwait(false));
waitForReady(() => this, _ => importTask.Start());
return importTask;
2019-02-25 11:58:58 +08:00
}
2019-09-25 21:13:49 +08:00
protected virtual Loader CreateLoader() => new Loader();
2020-03-05 12:34:04 +08:00
protected virtual UpdateManager CreateUpdateManager() => new UpdateManager();
protected override Container CreateScalingContainer() => new ScalingContainer(ScalingMode.Everything);
2019-08-13 11:06:57 +08:00
#region Beatmap progression
private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> beatmap)
{
beatmap.OldValue?.CancelAsyncLoad();
2020-08-05 20:21:08 +08:00
beatmap.NewValue?.BeginAsyncLoad();
}
private void modsChanged(ValueChangedEvent<IReadOnlyList<Mod>> mods)
{
// a lease may be taken on the mods bindable, at which point we can't really ensure valid mods.
if (SelectedMods.Disabled)
return;
if (!ModUtils.CheckValidForGameplay(mods.NewValue, out var invalid))
{
// ensure we always have a valid set of mods.
SelectedMods.Value = mods.NewValue.Except(invalid).ToArray();
}
}
#endregion
private PerformFromMenuRunner performFromMainMenuTask;
2019-02-25 11:58:58 +08:00
public void PerformFromScreen(Action<IScreen> action, IEnumerable<Type> validScreens = null)
2019-02-25 11:58:58 +08:00
{
performFromMainMenuTask?.Cancel();
Add(performFromMainMenuTask = new PerformFromMenuRunner(action, validScreens, () => ScreenStack.CurrentScreen));
2017-03-04 18:02:36 +08:00
}
2018-04-13 17:19:50 +08:00
public override void AttemptExit()
{
// The main menu exit implementation gives the user a chance to interrupt the exit process if needed.
PerformFromScreen(menu => menu.Exit(), new[] { typeof(MainMenu) });
}
/// <summary>
/// Wait for the game (and target component) to become loaded and then run an action.
/// </summary>
/// <param name="retrieveInstance">A function to retrieve a (potentially not-yet-constructed) target instance.</param>
/// <param name="action">The action to perform on the instance when load is confirmed.</param>
/// <typeparam name="T">The type of the target instance.</typeparam>
private void waitForReady<T>(Func<T> retrieveInstance, Action<T> action)
where T : Drawable
{
var instance = retrieveInstance();
if (ScreenStack == null || ScreenStack.CurrentScreen is StartupScreen || instance?.IsLoaded != true)
Schedule(() => waitForReady(retrieveInstance, action));
else
action(instance);
}
2018-08-03 18:25:55 +08:00
protected override void Dispose(bool isDisposing)
{
base.Dispose(isDisposing);
2019-11-12 22:08:16 +08:00
SentryLogger.Dispose();
2018-08-03 18:25:55 +08:00
}
protected override IDictionary<FrameworkSetting, object> GetFrameworkConfigDefaults()
{
return new Dictionary<FrameworkSetting, object>
{
// General expectation that osu! starts in fullscreen by default (also gives the most predictable performance).
// However, macOS is bound to have issues when using exclusive fullscreen as it takes full control away from OS, therefore borderless is default there.
{ FrameworkSetting.WindowMode, RuntimeInfo.OS == RuntimeInfo.Platform.macOS ? WindowMode.Borderless : WindowMode.Fullscreen },
{ FrameworkSetting.VolumeUniversal, 0.6 },
{ FrameworkSetting.VolumeMusic, 0.6 },
{ FrameworkSetting.VolumeEffect, 0.6 },
};
}
protected override void LoadComplete()
{
base.LoadComplete();
2018-04-13 17:19:50 +08:00
if (RuntimeInfo.EntryAssembly.GetCustomAttribute<OfficialBuildAttribute>() == null)
Logger.Log(NotificationsStrings.NotOfficialBuild.ToString());
2022-12-27 03:36:39 +08:00
var languages = Enum.GetValues<Language>();
var mappings = languages.Select(language =>
2021-04-20 16:06:01 +08:00
{
#if DEBUG
if (language == Language.debug)
return new LocaleMapping("debug", new DebugLocalisationStore());
#endif
string cultureCode = language.ToCultureCode();
try
{
return new LocaleMapping(new ResourceManagerLocalisationStore(cultureCode));
}
catch (Exception ex)
{
Logger.Error(ex, $"Could not load localisations for language \"{cultureCode}\"");
return null;
}
}).Where(m => m != null);
Localisation.AddLocaleMappings(mappings);
2021-04-20 16:06:01 +08:00
// The next time this is updated is in UpdateAfterChildren, which occurs too late and results
// in the cursor being shown for a few frames during the intro.
// This prevents the cursor from showing until we have a screen with CursorVisible = true
GlobalCursorDisplay.ShowCursor = menuScreen?.CursorVisible ?? false;
// todo: all archive managers should be able to be looped here.
2021-08-07 03:36:40 +08:00
SkinManager.PostNotification = n => Notifications.Post(n);
SkinManager.PresentImport = items => PresentSkin(items.First().Value);
2018-04-13 17:19:50 +08:00
2021-08-07 03:36:40 +08:00
BeatmapManager.PostNotification = n => Notifications.Post(n);
2022-06-20 17:21:37 +08:00
BeatmapManager.PresentImport = items => PresentBeatmap(items.First().Value);
BeatmapDownloader.PostNotification = n => Notifications.Post(n);
ScoreDownloader.PostNotification = n => Notifications.Post(n);
2021-08-07 03:36:40 +08:00
ScoreManager.PostNotification = n => Notifications.Post(n);
2022-06-20 17:21:37 +08:00
ScoreManager.PresentImport = items => PresentScore(items.First().Value);
2018-04-13 17:19:50 +08:00
2022-09-15 19:54:06 +08:00
MultiplayerClient.PostNotification = n => Notifications.Post(n);
2023-10-12 16:59:47 +08:00
MultiplayerClient.PresentMatch = PresentMultiplayerMatch;
2022-09-15 19:54:06 +08:00
// make config aware of how to lookup skins for on-screen display purposes.
// if this becomes a more common thing, tracked settings should be reconsidered to allow local DI.
2021-11-29 16:15:26 +08:00
LocalConfig.LookupSkinName = id => SkinManager.Query(s => s.ID == id)?.ToString() ?? "Unknown";
LocalConfig.LookupKeyBindings = l =>
{
var combinations = KeyBindingStore.GetReadableKeyCombinationsFor(l);
if (combinations.Count == 0)
2021-10-11 16:02:26 +08:00
return ToastStrings.NoKeyBound;
2021-10-11 16:11:41 +08:00
return string.Join(" / ", combinations);
};
2024-05-16 12:20:55 +08:00
ScreenFooter.BackReceptor backReceptor;
2019-01-23 19:52:00 +08:00
dependencies.CacheAs(idleTracker = new GameIdleTracker(6000));
var sessionIdleTracker = new GameIdleTracker(300000);
sessionIdleTracker.IsIdle.BindValueChanged(idle =>
2021-04-16 17:53:27 +08:00
{
if (idle.NewValue)
SessionStatics.ResetAfterInactivity();
2021-04-16 17:53:27 +08:00
});
Add(sessionIdleTracker);
2024-07-12 20:25:21 +08:00
Container logoContainer;
2017-10-23 12:08:58 +08:00
AddRange(new Drawable[]
{
new VolumeControlReceptor
{
RelativeSizeAxes = Axes.Both,
ActionRequested = action => volume.Adjust(action),
2018-07-05 15:50:04 +08:00
ScrollActionRequested = (action, amount, isPrecise) => volume.Adjust(action, amount, isPrecise),
},
2021-08-07 03:36:40 +08:00
ScreenOffsetContainer = new Container
2019-01-04 12:29:37 +08:00
{
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
ScreenContainer = new ScalingContainer(ScalingMode.ExcludeOverlays)
2019-06-25 16:16:38 +08:00
{
RelativeSizeAxes = Axes.Both,
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Children = new Drawable[]
{
2024-05-16 12:20:55 +08:00
backReceptor = new ScreenFooter.BackReceptor(),
ScreenStack = new OsuScreenStack { RelativeSizeAxes = Axes.Both },
2024-05-16 12:20:55 +08:00
BackButton = new BackButton(backReceptor)
{
Anchor = Anchor.BottomLeft,
Origin = Anchor.BottomLeft,
2024-05-16 12:20:55 +08:00
Action = () => ScreenFooter.OnBack?.Invoke(),
},
logoContainer = new Container { RelativeSizeAxes = Axes.Both },
footerBasedOverlayContent = new Container
{
Depth = -1,
RelativeSizeAxes = Axes.Both,
},
2024-05-16 12:20:55 +08:00
new PopoverContainer
{
Depth = -1,
2024-05-16 12:20:55 +08:00
RelativeSizeAxes = Axes.Both,
Child = ScreenFooter = new ScreenFooter(backReceptor)
{
2024-07-12 18:20:41 +08:00
RequestLogoInFront = inFront => ScreenContainer.ChangeChildDepth(logoContainer, inFront ? float.MinValue : 0),
2024-05-16 12:20:55 +08:00
OnBack = () =>
{
if (!(ScreenStack.CurrentScreen is IOsuScreen currentScreen))
return;
if (!((Drawable)currentScreen).IsLoaded || (currentScreen.AllowBackButton && !currentScreen.OnBackButton()))
ScreenStack.Exit();
}
},
},
}
2019-06-25 16:16:38 +08:00
},
}
2019-01-04 12:29:37 +08:00
},
overlayOffsetContainer = new Container
{
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
overlayContent = new Container { RelativeSizeAxes = Axes.Both },
leftFloatingOverlayContent = new Container { RelativeSizeAxes = Axes.Both },
rightFloatingOverlayContent = new Container { RelativeSizeAxes = Axes.Both },
}
},
2019-03-22 02:16:10 +08:00
topMostOverlayContent = new Container { RelativeSizeAxes = Axes.Both },
2020-08-16 20:22:39 +08:00
idleTracker,
2020-10-07 15:41:47 +08:00
new ConfineMouseTracker()
2016-09-30 17:45:55 +08:00
});
2018-04-13 17:19:50 +08:00
2024-05-16 12:20:55 +08:00
dependencies.Cache(ScreenFooter);
ScreenStack.ScreenPushed += screenPushed;
ScreenStack.ScreenExited += screenExited;
2019-01-23 19:52:00 +08:00
2022-07-20 20:05:20 +08:00
loadComponentSingleFile(fpsCounter = new FPSCounter
{
Anchor = Anchor.BottomRight,
Origin = Anchor.BottomRight,
2022-07-20 22:59:09 +08:00
Margin = new MarginPadding(5),
}, topMostOverlayContent.Add);
if (!IsDeployedBuild)
{
dependencies.Cache(versionManager = new VersionManager());
loadComponentSingleFile(versionManager, ScreenContainer.Add);
}
2022-01-16 22:20:22 +08:00
loadComponentSingleFile(osuLogo, _ =>
2016-11-01 22:24:14 +08:00
{
osuLogo.SetupDefaultContainer(logoContainer);
2019-01-23 19:52:00 +08:00
// Loader has to be created after the logo has finished loading as Loader performs logo transformations on entering.
2019-07-31 15:03:05 +08:00
ScreenStack.Push(CreateLoader().With(l => l.RelativeSizeAxes = Axes.Both));
2019-03-12 15:03:25 +08:00
});
2018-04-13 17:19:50 +08:00
loadComponentSingleFile(new UserStatisticsWatcher(), Add, true);
loadComponentSingleFile(Toolbar = new Toolbar
{
OnHome = delegate
{
2018-06-06 15:17:51 +08:00
CloseAllOverlays(false);
if (menuScreen?.GetChildScreen() != null)
menuScreen.MakeCurrent();
},
2019-11-08 22:04:18 +08:00
}, topMostOverlayContent.Add);
2018-04-13 17:19:50 +08:00
loadComponentSingleFile(volume = new VolumeOverlay(), leftFloatingOverlayContent.Add, true);
onScreenDisplay = new OnScreenDisplay();
onScreenDisplay.BeginTracking(this, frameworkConfig);
onScreenDisplay.BeginTracking(this, LocalConfig);
loadComponentSingleFile(onScreenDisplay, Add, true);
loadComponentSingleFile<INotificationOverlay>(Notifications.With(d =>
{
d.Anchor = Anchor.TopRight;
d.Origin = Anchor.TopRight;
}), rightFloatingOverlayContent.Add, true);
2021-11-25 16:12:15 +08:00
loadComponentSingleFile(legacyImportManager, Add);
loadComponentSingleFile(screenshotManager, Add);
2018-04-13 17:19:50 +08:00
2020-05-08 07:09:16 +08:00
// dependency on notification overlay, dependent by settings overlay
2020-05-08 05:04:18 +08:00
loadComponentSingleFile(CreateUpdateManager(), Add, true);
2020-05-05 09:31:11 +08:00
// overlay elements
loadComponentSingleFile(FirstRunOverlay = new FirstRunSetupOverlay(), footerBasedOverlayContent.Add, true);
2020-09-07 20:08:48 +08:00
loadComponentSingleFile(new ManageCollectionsDialog(), overlayContent.Add, true);
loadComponentSingleFile(beatmapListing = new BeatmapListingOverlay(), overlayContent.Add, true);
loadComponentSingleFile(dashboard = new DashboardOverlay(), overlayContent.Add, true);
2020-07-16 19:48:40 +08:00
loadComponentSingleFile(news = new NewsOverlay(), overlayContent.Add, true);
2020-02-13 19:26:35 +08:00
var rankingsOverlay = loadComponentSingleFile(new RankingsOverlay(), overlayContent.Add, true);
loadComponentSingleFile(channelManager = new ChannelManager(API), Add, true);
loadComponentSingleFile(chatOverlay = new ChatOverlay(), overlayContent.Add, true);
loadComponentSingleFile(new MessageNotifier(), Add, true);
loadComponentSingleFile(Settings = new SettingsOverlay(), leftFloatingOverlayContent.Add, true);
loadComponentSingleFile(changelogOverlay = new ChangelogOverlay(), overlayContent.Add, true);
loadComponentSingleFile(userProfile = new UserProfileOverlay(), overlayContent.Add, true);
loadComponentSingleFile(beatmapSetOverlay = new BeatmapSetOverlay(), overlayContent.Add, true);
2021-04-22 17:16:12 +08:00
loadComponentSingleFile(wikiOverlay = new WikiOverlay(), overlayContent.Add, true);
loadComponentSingleFile(skinEditor = new SkinEditorOverlay(ScreenContainer), overlayContent.Add, true);
2019-11-12 14:03:58 +08:00
loadComponentSingleFile(new LoginOverlay
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
}, rightFloatingOverlayContent.Add, true);
2018-04-13 17:19:50 +08:00
loadComponentSingleFile(new NowPlayingOverlay
2017-02-10 15:26:43 +08:00
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
2019-11-08 22:04:18 +08:00
}, rightFloatingOverlayContent.Add, true);
2018-04-13 17:19:50 +08:00
loadComponentSingleFile(new AccountCreationOverlay(), topMostOverlayContent.Add, true);
loadComponentSingleFile<IDialogOverlay>(new DialogOverlay(), topMostOverlayContent.Add, true);
loadComponentSingleFile(new MedalOverlay(), topMostOverlayContent.Add);
loadComponentSingleFile(new BackgroundDataStoreProcessor(), Add);
2024-08-27 16:37:15 +08:00
loadComponentSingleFile(new DetachedBeatmapStore(), Add, true);
2022-07-21 02:18:57 +08:00
2021-06-16 10:48:41 +08:00
Add(difficultyRecommender);
Add(externalLinkOpener = new ExternalLinkOpener());
2020-09-08 17:10:14 +08:00
Add(new MusicKeyBindingHandler());
Add(new OnlineStatusNotifier(() => ScreenStack.CurrentScreen));
2019-11-12 14:03:58 +08:00
// side overlays which cancel each other.
2022-06-15 08:34:08 +08:00
var singleDisplaySideOverlays = new OverlayContainer[] { Settings, Notifications, FirstRunOverlay };
2018-06-06 15:17:51 +08:00
foreach (var overlay in singleDisplaySideOverlays)
{
overlay.State.ValueChanged += state =>
{
if (state.NewValue == Visibility.Hidden) return;
2019-02-28 12:31:40 +08:00
singleDisplaySideOverlays.Where(o => o != overlay).ForEach(o => o.Hide());
};
}
2018-04-13 17:19:50 +08:00
// eventually informational overlays should be displayed in a stack, but for now let's only allow one to stay open at a time.
2019-05-31 12:23:50 +08:00
var informationalOverlays = new OverlayContainer[] { beatmapSetOverlay, userProfile };
2018-06-06 15:17:51 +08:00
foreach (var overlay in informationalOverlays)
{
overlay.State.ValueChanged += state =>
{
if (state.NewValue != Visibility.Hidden)
showOverlayAboveOthers(overlay, informationalOverlays);
};
}
2018-04-13 17:19:50 +08:00
// ensure only one of these overlays are open at once.
var singleDisplayOverlays = new OverlayContainer[] { chatOverlay, news, dashboard, beatmapListing, changelogOverlay, rankingsOverlay, wikiOverlay };
2018-06-06 15:17:51 +08:00
foreach (var overlay in singleDisplayOverlays)
{
overlay.State.ValueChanged += state =>
{
// informational overlays should be dismissed on a show or hide of a full overlay.
informationalOverlays.ForEach(o => o.Hide());
if (state.NewValue != Visibility.Hidden)
showOverlayAboveOthers(overlay, singleDisplayOverlays);
};
}
2018-04-13 17:19:50 +08:00
OverlayActivationMode.ValueChanged += mode =>
2018-06-06 15:17:51 +08:00
{
if (mode.NewValue != OverlayActivation.All) CloseAllOverlays();
2018-06-06 15:17:51 +08:00
};
// Importantly, this should be run after binding PostNotification to the import handlers so they can present the import after game startup.
handleStartupImport();
}
private void handleStartupImport()
{
if (args?.Length > 0)
{
string[] paths = args.Where(a => !a.StartsWith('-')).ToArray();
if (paths.Length > 0)
{
string firstPath = paths.First();
if (firstPath.StartsWith(OSU_PROTOCOL, StringComparison.Ordinal))
{
HandleLink(firstPath);
}
else
{
Task.Run(() => Import(paths));
}
}
}
}
private void showOverlayAboveOthers(OverlayContainer overlay, OverlayContainer[] otherOverlays)
{
otherOverlays.Where(o => o != overlay).ForEach(o => o.Hide());
Settings.Hide();
Notifications.Hide();
// Partially visible so leave it at the current depth.
if (overlay.IsPresent)
return;
2019-01-23 19:37:56 +08:00
// Show above all other overlays.
if (overlay.IsLoaded)
overlayContent.ChangeChildDepth(overlay, (float)-Clock.CurrentTime);
else
overlay.Depth = (float)-Clock.CurrentTime;
}
2022-09-22 18:17:01 +08:00
private void forwardGeneralLogsToNotifications()
{
int recentLogCount = 0;
2018-04-13 17:19:50 +08:00
const double debounce = 60000;
2018-04-13 17:19:50 +08:00
Logger.NewEntry += entry =>
{
2022-12-23 01:07:53 +08:00
if (entry.Level < LogLevel.Important || entry.Target > LoggingTarget.Database || entry.Target == null) return;
2022-12-19 15:41:04 +08:00
2024-03-01 12:34:21 +08:00
if (entry.Exception is SentryOnlyDiagnosticsException)
return;
const int short_term_display_limit = 3;
if (recentLogCount < short_term_display_limit)
{
2021-08-07 03:36:40 +08:00
Schedule(() => Notifications.Post(new SimpleErrorNotification
{
2019-04-02 18:55:24 +08:00
Icon = entry.Level == LogLevel.Important ? FontAwesome.Solid.ExclamationCircle : FontAwesome.Solid.Bomb,
Text = entry.Message.Truncate(256) + (entry.Exception != null && IsDeployedBuild ? "\n\nThis error has been automatically reported to the devs." : string.Empty),
}));
}
else if (recentLogCount == short_term_display_limit)
{
string logFile = Logger.GetLogger(entry.Target.Value).Filename;
2021-08-07 03:36:40 +08:00
Schedule(() => Notifications.Post(new SimpleNotification
{
2019-04-02 18:55:24 +08:00
Icon = FontAwesome.Solid.EllipsisH,
2023-06-28 02:56:35 +08:00
Text = NotificationsStrings.SubsequentMessagesLogged,
Activated = () =>
{
Logger.Storage.PresentFileExternally(logFile);
return true;
}
}));
}
2018-04-13 17:19:50 +08:00
Interlocked.Increment(ref recentLogCount);
Scheduler.AddDelayed(() => Interlocked.Decrement(ref recentLogCount), debounce);
};
}
2018-04-13 17:19:50 +08:00
private void forwardTabletLogsToNotifications()
{
const string tablet_prefix = @"[Tablet] ";
bool notifyOnWarning = true;
bool notifyOnError = true;
Logger.NewEntry += entry =>
{
if (entry.Level < LogLevel.Important || entry.Target != LoggingTarget.Input || !entry.Message.StartsWith(tablet_prefix, StringComparison.OrdinalIgnoreCase))
return;
string message = entry.Message.Replace(tablet_prefix, string.Empty);
if (entry.Level == LogLevel.Error)
{
if (!notifyOnError)
return;
notifyOnError = false;
Schedule(() =>
{
Notifications.Post(new SimpleNotification
{
2023-06-28 02:56:35 +08:00
Text = NotificationsStrings.TabletSupportDisabledDueToError(message),
Icon = FontAwesome.Solid.PenSquare,
IconColour = Colours.RedDark,
});
// We only have one tablet handler currently.
// The loop here is weakly guarding against a future where more than one is added.
// If this is ever the case, this logic needs adjustment as it should probably only
// disable the relevant tablet handler rather than all.
foreach (var tabletHandler in Host.AvailableInputHandlers.OfType<ITabletHandler>())
tabletHandler.Enabled.Value = false;
});
}
else if (notifyOnWarning)
{
Schedule(() => Notifications.Post(new SimpleNotification
{
2023-06-28 02:56:35 +08:00
Text = NotificationsStrings.EncounteredTabletWarning,
Icon = FontAwesome.Solid.PenSquare,
IconColour = Colours.YellowDark,
Activated = () =>
{
OpenUrlExternally("https://opentabletdriver.net/Tablets", true);
return true;
}
}));
notifyOnWarning = false;
}
};
Schedule(() =>
{
ITabletHandler tablet = Host.AvailableInputHandlers.OfType<ITabletHandler>().SingleOrDefault();
tablet?.Tablet.BindValueChanged(_ =>
{
notifyOnWarning = true;
notifyOnError = true;
}, true);
});
}
private Task asyncLoadStream;
2018-04-13 17:19:50 +08:00
2020-05-12 11:49:35 +08:00
/// <summary>
2020-05-13 10:09:17 +08:00
/// Queues loading the provided component in sequential fashion.
/// This operation is limited to a single thread to avoid saturating all cores.
2020-05-12 11:49:35 +08:00
/// </summary>
2020-05-13 10:09:17 +08:00
/// <param name="component">The component to load.</param>
/// <param name="loadCompleteAction">An action to invoke on load completion (generally to add the component to the hierarchy).</param>
2020-05-12 11:49:35 +08:00
/// <param name="cache">Whether to cache the component as type <typeparamref name="T"/> into the game dependencies before any scheduling.</param>
private T loadComponentSingleFile<T>(T component, Action<Drawable> loadCompleteAction, bool cache = false)
where T : class
{
if (cache)
2020-05-13 10:09:17 +08:00
dependencies.CacheAs(component);
2022-04-18 19:04:19 +08:00
var drawableComponent = component as Drawable ?? throw new ArgumentException($"Component must be a {nameof(Drawable)}", nameof(component));
if (component is OsuFocusedOverlayContainer overlay)
focusedOverlays.Add(overlay);
2019-11-12 14:03:58 +08:00
// schedule is here to ensure that all component loads are done after LoadComplete is run (and thus all dependencies are cached).
// with some better organisation of LoadComplete to do construction and dependency caching in one step, followed by calls to loadComponentSingleFile,
// we could avoid the need for scheduling altogether.
2018-08-20 15:06:12 +08:00
Schedule(() =>
{
var previousLoadStream = asyncLoadStream;
2020-05-05 09:31:11 +08:00
// chain with existing load stream
asyncLoadStream = Task.Run(async () =>
{
if (previousLoadStream != null)
await previousLoadStream.ConfigureAwait(false);
try
2018-08-20 15:06:12 +08:00
{
Logger.Log($"Loading {component}...");
2019-02-28 16:17:51 +08:00
// Since this is running in a separate thread, it is possible for OsuGame to be disposed after LoadComponentAsync has been called
// throwing an exception. To avoid this, the call is scheduled on the update thread, which does not run if IsDisposed = true
Task task = null;
var del = new ScheduledDelegate(() => task = LoadComponentAsync(drawableComponent, loadCompleteAction));
2019-02-28 16:17:51 +08:00
Scheduler.Add(del);
// The delegate won't complete if OsuGame has been disposed in the meantime
while (!IsDisposed && !del.Completed)
await Task.Delay(10).ConfigureAwait(false);
2019-02-28 16:17:51 +08:00
// Either we're disposed or the load process has started successfully
if (IsDisposed)
return;
2019-02-28 16:17:51 +08:00
Debug.Assert(task != null);
await task.ConfigureAwait(false);
2019-02-28 16:17:51 +08:00
Logger.Log($"Loaded {component}!");
}
catch (OperationCanceledException)
{
}
});
2018-08-20 15:06:12 +08:00
});
2020-05-13 10:09:17 +08:00
return component;
}
2021-09-16 17:26:12 +08:00
public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
{
if (e.Repeat)
return false;
2019-01-23 19:52:00 +08:00
if (introScreen == null) return false;
2018-04-13 17:19:50 +08:00
2021-09-16 17:26:12 +08:00
switch (e.Action)
{
2022-07-20 20:05:20 +08:00
case GlobalAction.ToggleFPSDisplay:
fpsCounter.ToggleVisibility();
return true;
case GlobalAction.ToggleSkinEditor:
skinEditor.ToggleVisibility();
return true;
case GlobalAction.ResetInputSettings:
Host.ResetInputHandlers();
frameworkConfig.GetBindable<ConfineMouseMode>(FrameworkSetting.ConfineMouseMode).SetDefault();
return true;
2019-04-01 11:16:05 +08:00
2018-05-02 18:42:03 +08:00
case GlobalAction.ToggleGameplayMouseButtons:
var mouseDisableButtons = LocalConfig.GetBindable<bool>(OsuSetting.MouseDisableButtons);
mouseDisableButtons.Value = !mouseDisableButtons.Value;
return true;
2019-04-01 11:16:05 +08:00
2022-08-10 02:43:37 +08:00
case GlobalAction.ToggleProfile:
if (userProfile.State.Value == Visibility.Visible)
2022-08-11 01:31:58 +08:00
userProfile.Hide();
else
2022-08-11 12:17:14 +08:00
ShowUser(API.LocalUser.Value);
return true;
2022-08-10 02:43:37 +08:00
2020-11-11 12:05:03 +08:00
case GlobalAction.RandomSkin:
// Don't allow random skin selection while in the skin editor.
// This is mainly to stop many "osu! default (modified)" skins being created via the SkinManager.EnsureMutableSkin() path.
// If people want this to work we can potentially avoid selecting default skins when the editor is open, or allow a maximum of one mutable skin somehow.
if (skinEditor.State.Value == Visibility.Visible)
return false;
2020-11-11 12:05:03 +08:00
SkinManager.SelectRandomSkin();
2018-05-02 18:37:47 +08:00
return true;
2016-11-08 18:27:37 +08:00
}
2018-04-13 17:19:50 +08:00
2017-02-27 23:18:12 +08:00
return false;
}
2018-04-13 17:19:50 +08:00
public override bool OnPressed(KeyBindingPressEvent<PlatformAction> e)
{
const float adjustment_increment = 0.05f;
switch (e.Action)
{
case PlatformAction.ZoomIn:
uiScale.Value += adjustment_increment;
return true;
case PlatformAction.ZoomOut:
uiScale.Value -= adjustment_increment;
return true;
case PlatformAction.ZoomDefault:
uiScale.SetDefault();
return true;
}
return base.OnPressed(e);
}
2019-06-17 22:25:16 +08:00
#region Inactive audio dimming
2019-06-17 22:24:52 +08:00
private readonly BindableDouble inactiveVolumeFade = new BindableDouble();
2018-04-13 17:19:50 +08:00
private void updateActiveState(bool isActive)
{
if (isActive)
this.TransformBindableTo(inactiveVolumeFade, 1, 400, Easing.OutQuint);
else
this.TransformBindableTo(inactiveVolumeFade, LocalConfig.Get<double>(OsuSetting.VolumeInactive), 4000, Easing.OutQuint);
}
2018-04-13 17:19:50 +08:00
2019-06-17 22:25:16 +08:00
#endregion
2021-09-16 17:26:12 +08:00
public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
{
}
2018-04-13 17:19:50 +08:00
protected override bool OnExiting()
{
if (ScreenStack.CurrentScreen is Loader)
return false;
if (introScreen?.DidLoadMenu == true && !(ScreenStack.CurrentScreen is IntroScreen))
{
Scheduler.Add(introScreen.MakeCurrent);
return true;
}
return base.OnExiting();
}
2017-02-08 18:32:55 +08:00
protected override void UpdateAfterChildren()
{
base.UpdateAfterChildren();
2018-04-13 17:19:50 +08:00
ScreenOffsetContainer.Padding = new MarginPadding { Top = toolbarOffset };
overlayOffsetContainer.Padding = new MarginPadding { Top = toolbarOffset };
2018-04-13 17:19:50 +08:00
float horizontalOffset = 0f;
// Content.ToLocalSpace() is used instead of this.ToLocalSpace() to correctly calculate the offset with scaling modes active.
// Content is a child of a scaling container with ScalingMode.Everything set, while the game itself is never scaled.
// this avoids a visible jump in the positioning of the screen offset container.
if (Settings.IsLoaded && Settings.IsPresent)
horizontalOffset += Content.ToLocalSpace(Settings.ScreenSpaceDrawQuad.TopRight).X * SIDE_OVERLAY_OFFSET_RATIO;
if (Notifications.IsLoaded && Notifications.IsPresent)
horizontalOffset += (Content.ToLocalSpace(Notifications.ScreenSpaceDrawQuad.TopLeft).X - Content.DrawWidth) * SIDE_OVERLAY_OFFSET_RATIO;
ScreenOffsetContainer.X = horizontalOffset;
overlayContent.X = horizontalOffset * 1.2f;
GlobalCursorDisplay.ShowCursor = (ScreenStack.CurrentScreen as IOsuScreen)?.CursorVisible ?? false;
2017-02-08 18:32:55 +08:00
}
2018-04-13 17:19:50 +08:00
private void screenChanged(IScreen current, IScreen newScreen)
{
2022-05-11 11:55:15 +08:00
SentrySdk.ConfigureScope(scope =>
{
scope.Contexts[@"screen stack"] = new
{
Current = newScreen?.GetType().ReadableName(),
Previous = current?.GetType().ReadableName(),
2022-05-11 11:55:15 +08:00
};
scope.SetTag(@"screen", newScreen?.GetType().ReadableName() ?? @"none");
2022-05-11 11:55:15 +08:00
});
2019-01-23 19:52:00 +08:00
switch (newScreen)
{
case IntroScreen intro:
2019-01-23 19:52:00 +08:00
introScreen = intro;
versionManager?.Show();
2019-01-23 19:52:00 +08:00
break;
2019-04-01 11:16:05 +08:00
2019-01-23 19:52:00 +08:00
case MainMenu menu:
menuScreen = menu;
versionManager?.Show();
break;
default:
versionManager?.Hide();
2019-01-23 19:52:00 +08:00
break;
}
2020-10-08 17:29:19 +08:00
// reset on screen change for sanity.
LocalUserPlaying.Value = false;
if (current is IOsuScreen currentOsuScreen)
2020-11-08 19:29:52 +08:00
{
OverlayActivationMode.UnbindFrom(currentOsuScreen.OverlayActivationMode);
2020-11-08 19:29:52 +08:00
API.Activity.UnbindFrom(currentOsuScreen.Activity);
}
if (newScreen is IOsuScreen newOsuScreen)
{
OverlayActivationMode.BindTo(newOsuScreen.OverlayActivationMode);
API.Activity.BindTo(newOsuScreen.Activity);
GlobalCursorDisplay.MenuCursor.HideCursorOnNonMouseInput = newOsuScreen.HideMenuCursorOnNonMouseInput;
if (newOsuScreen.HideOverlaysOnEnter)
CloseAllOverlays();
else
Toolbar.Show();
2019-06-25 15:55:49 +08:00
2019-06-25 17:38:14 +08:00
if (newOsuScreen.AllowBackButton)
BackButton.Show();
2019-06-25 17:30:43 +08:00
else
BackButton.Hide();
2024-05-16 12:20:55 +08:00
if (newOsuScreen.ShowFooter)
{
BackButton.Hide();
ScreenFooter.SetButtons(newOsuScreen.CreateFooterButtons());
ScreenFooter.Show();
}
else
{
ScreenFooter.SetButtons(Array.Empty<ScreenFooterButton>());
ScreenFooter.Hide();
}
}
skinEditor.SetTarget((OsuScreen)newScreen);
}
private void screenPushed(IScreen lastScreen, IScreen newScreen) => screenChanged(lastScreen, newScreen);
2018-04-13 17:19:50 +08:00
2019-01-23 19:52:00 +08:00
private void screenExited(IScreen lastScreen, IScreen newScreen)
{
screenChanged(lastScreen, newScreen);
2018-04-13 17:19:50 +08:00
2017-12-26 15:09:40 +08:00
if (newScreen == null)
Exit();
2016-08-26 11:28:23 +08:00
}
IBindable<bool> ILocalUserPlayInfo.IsPlaying => LocalUserPlaying;
2016-08-26 11:28:23 +08:00
}
}