{

#if DEBUG

// Different port allows runnning 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;

public Toolbar Toolbar { get; private set; }

private ChatOverlay chatOverlay;

private ChannelManager channelManager;

[NotNull]

protected readonly NotificationOverlay Notifications = new NotificationOverlay();

private BeatmapListingOverlay beatmapListing;

private DashboardOverlay dashboard;

private NewsOverlay news;

private UserProfileOverlay userProfile;

private BeatmapSetOverlay beatmapSetOverlay;

private WikiOverlay wikiOverlay;

private ChangelogOverlay changelogOverlay;

private SkinEditorOverlay skinEditor;

private Container overlayContent;

private Container rightFloatingOverlayContent;

private Container leftFloatingOverlayContent;

private Container topMostOverlayContent;

protected ScalingContainer ScreenContainer { get; private set; }

protected Container ScreenOffsetContainer { get; private set; }

private Container overlayOffsetContainer;

[Resolved]

private FrameworkConfigManager frameworkConfig { get; set; }

[Cached]

private readonly DifficultyRecommender difficultyRecommender = new DifficultyRecommender();

[Cached]

private readonly LegacyImportManager legacyImportManager = new LegacyImportManager();

[Cached]

private readonly ScreenshotManager screenshotManager = new ScreenshotManager();

protected SentryLogger SentryLogger;

public virtual StableStorage GetStorageForStableInstall() => null;

private float toolbarOffset => (Toolbar?.Position.Y ?? 0) + (Toolbar?.DrawHeight ?? 0);

private IdleTracker idleTracker;

/// <summary>

/// Whether the user is currently in an idle state.

/// </summary>

public IBindable<bool> IsIdle => idleTracker.IsIdle;

/// <summary>

/// Whether overlays should be able to be opened game-wide. Value is sourced from the current active screen.

/// </summary>

public readonly IBindable<OverlayActivation> OverlayActivationMode = new Bindable<OverlayActivation>();

/// <summary>

/// Whether the local user is currently interacting with the game in a way that should not be interrupted.

/// </summary>

/// <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();

protected OsuScreenStack ScreenStack;

protected BackButton BackButton;

protected SettingsOverlay Settings;

protected FirstRunSetupOverlay FirstRunOverlay { get; private set; }

private FPSCounter fpsCounter;

private VolumeOverlay volume;

private OsuLogo osuLogo;

private MainMenu menuScreen;

private VersionManager versionManager;

[CanBeNull]

private IntroScreen introScreen;

private Bindable<string> configRuleset;

private Bindable<bool> applySafeAreaConsiderations;

private Bindable<float> uiScale;

private Bindable<string> configSkin;

private readonly string[] args;

private readonly List<OsuFocusedOverlayContainer> focusedOverlays = new List<OsuFocusedOverlayContainer>();

private readonly List<OverlayContainer> externalOverlays = new List<OverlayContainer>();

private readonly List<OverlayContainer> visibleBlockingOverlays = new List<OverlayContainer>();

public OsuGame(string[] args = null)

{

this.args = args;

forwardGeneralLogsToNotifications();

forwardTabletLogsToNotifications();

SentryLogger = new SentryLogger(this);

}

#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);

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(() =>

{

visibleBlockingOverlays.Remove(overlay);

updateBlockingOverlayFade();

});

/// <summary>

/// Unregisters a blocking <see cref="OverlayContainer"/> that was not created by <see cref="OsuGame"/> itself.

/// </summary>

private void unregisterBlockingOverlay(OverlayContainer overlayContainer) => Schedule(() =>

{

externalOverlays.Remove(overlayContainer);

if (overlayContainer is OsuFocusedOverlayContainer focusedOverlayContainer)

focusedOverlays.Remove(focusedOverlayContainer);

overlayContainer.Expire();

});

#endregion

/// <summary>

/// Close all game-wide overlays.

/// </summary>

/// <param name="hideToolbar">Whether the toolbar should also be hidden.</param>

public void CloseAllOverlays(bool hideToolbar = true)

{

foreach (var overlay in focusedOverlays)

overlay.Hide();

if (hideToolbar) Toolbar.Hide();

}

protected override UserInputManager CreateUserInputManager()

{

var userInputManager = base.CreateUserInputManager();

(userInputManager as OsuUserInputManager)?.LocalUserPlaying.BindTo(LocalUserPlaying);

return userInputManager;

}

private DependencyContainer dependencies;

protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>

dependencies = new DependencyContainer(base.CreateChildDependencies(parent));

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]

private void load()

{

SentryLogger.AttachUser(API.LocalUser);

dependencies.Cache(osuLogo = new OsuLogo { Alpha = 0 });

// 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;

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();

LocalUserPlaying.BindValueChanged(p =>

{

BeatmapManager.PauseImports = p.NewValue;

SkinManager.PauseImports = p.NewValue;

ScoreManager.PauseImports = p.NewValue;

}, true);

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);

}

private ExternalLinkOpener externalLinkOpener;

/// <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>

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>

public void HandleLink(LinkDetails link) => Schedule(() =>

{

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;

case LinkAction.SearchBeatmapSet:

if (link.Argument is RomanisableString romanisable)

SearchBeatmapSet(romanisable.GetPreferred(Localisation.CurrentParameters.Value.PreferOriginalScript));

else

SearchBeatmapSet(argString);

break;

case LinkAction.FilterBeatmapSetGenre:

FilterBeatmapSetGenre((SearchGenre)link.Argument);

break;

case LinkAction.FilterBeatmapSetLanguage:

FilterBeatmapSetLanguage((SearchLanguage)link.Argument);

break;

case LinkAction.OpenEditorTimestamp:

HandleTimestamp(argString);

break;

case LinkAction.JoinMultiplayerMatch:

case LinkAction.Spectate:

waitForReady(() => Notifications, _ => Notifications.Post(new SimpleNotification

{

Text = NotificationsStrings.LinkTypeNotSupported,

Icon = FontAwesome.Solid.LifeRing,

}));

break;

case LinkAction.External:

OpenUrlExternally(argString);

break;

case LinkAction.OpenUserProfile:

ShowUser((IUser)link.Argument);

break;

case LinkAction.OpenWiki:

ShowWiki(argString);

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.");

}

});

public void OpenUrlExternally(string url, bool bypassExternalUrlWarning = false) => waitForReady(() => externalLinkOpener, _ =>

{

if (url.StartsWith('/'))

url = $"{API.APIEndpointUrl}{url}";

if (!url.CheckIsValidUrl())

{

Notifications.Post(new SimpleErrorNotification

{

Text = NotificationsStrings.UnsupportedOrDangerousUrlProtocol(url),

});

return;

}

externalLinkOpener.OpenUrlExternally(url, bypassExternalUrlWarning);

});

/// <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");

}

});

/// <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));

/// <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));

/// <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));

/// <summary>

/// Shows the beatmap listing overlay, with the given <paramref name="query"/> in the search box.

/// </summary>

/// <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));

/// <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));

/// <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>

/// 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>

public void HandleTimestamp(string timestamp)

{

if (ScreenStack.CurrentScreen is not Editor editor)

{

Schedule(() => Notifications.Post(new SimpleErrorNotification

{

Icon = FontAwesome.Solid.ExclamationTriangle,

Text = EditorStrings.MustBeInEditorToHandleLinks

}));

return;

}

editor.HandleTimestamp(timestamp);

}

/// <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>

/// <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);

if (beatmap is BeatmapSetInfo localBeatmap)

databasedSet ??= BeatmapManager.QueryBeatmapSet(s => s.Hash == localBeatmap.Hash);

if (databasedSet == null)

{

Logger.Log("The requested beatmap could not be loaded.", LoggingTarget.Information);

return;

}

var detachedSet = databasedSet.PerformRead(s => s.Detach());

if (detachedSet.DeletePending)

{

Logger.Log("The requested beatmap has since been deleted.", LoggingTarget.Information);

return;

}

PerformFromScreen(screen =>

{

// 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)

{

Logger.Log($"Beginning {nameof(PresentScore)} with score {score}");

var databasedScore = ScoreManager.GetScore(score);

if (databasedScore == null) return;

if (databasedScore.Replay == null)

{

Logger.Log("The loaded score has no replay data.", LoggingTarget.Information);

return;

}

var databasedBeatmap = BeatmapManager.QueryBeatmap(b => b.ID == databasedScore.ScoreInfo.BeatmapInfo.ID);

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, 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).

IEnumerable<Type> validScreens =

Beatmap.Value.BeatmapInfo.Equals(databasedBeatmap) && Ruleset.Value.Equals(databasedScore.ScoreInfo.Ruleset)

? new[] { typeof(SongSelect) }

: Array.Empty<Type>();

PerformFromScreen(screen =>

{

Logger.Log($"{nameof(PresentScore)} updating beatmap ({databasedBeatmap}) and ruleset ({databasedScore.ScoreInfo.Ruleset}) to match score");

Ruleset.Value = databasedScore.ScoreInfo.Ruleset;

Beatmap.Value = BeatmapManager.GetWorkingBeatmap(databasedBeatmap);

switch (presentType)

{

case ScorePresentType.Gameplay:

screen.Push(new ReplayPlayerLoader(databasedScore));

break;

case ScorePresentType.Results:

screen.Push(new SoloResultsScreen(databasedScore.ScoreInfo));

break;

}

}, validScreens: validScreens);

}

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;

}

protected virtual Loader CreateLoader() => new Loader();

protected virtual UpdateManager CreateUpdateManager() => new UpdateManager();

protected override Container CreateScalingContainer() => new ScalingContainer(ScalingMode.Everything);

#region Beatmap progression

private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> beatmap)

{

beatmap.OldValue?.CancelAsyncLoad();

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;

public void PerformFromScreen(Action<IScreen> action, IEnumerable<Type> validScreens = null)

{

performFromMainMenuTask?.Cancel();

Add(performFromMainMenuTask = new PerformFromMenuRunner(action, validScreens, () => ScreenStack.CurrentScreen));

}

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);

}

protected override void Dispose(bool isDisposing)

{

base.Dispose(isDisposing);

SentryLogger.Dispose();

}

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();

var languages = Enum.GetValues<Language>();

var mappings = languages.Select(language =>

{

#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);

// 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.

SkinManager.PostNotification = n => Notifications.Post(n);

SkinManager.PresentImport = items => PresentSkin(items.First().Value);

BeatmapManager.PostNotification = n => Notifications.Post(n);

BeatmapManager.PresentImport = items => PresentBeatmap(items.First().Value);

BeatmapDownloader.PostNotification = n => Notifications.Post(n);

ScoreDownloader.PostNotification = n => Notifications.Post(n);

ScoreManager.PostNotification = n => Notifications.Post(n);

ScoreManager.PresentImport = items => PresentScore(items.First().Value);

MultiplayerClient.PostNotification = n => Notifications.Post(n);

MultiplayerClient.PresentMatch = PresentMultiplayerMatch;

// 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.

LocalConfig.LookupSkinName = id => SkinManager.Query(s => s.ID == id)?.ToString() ?? "Unknown";

LocalConfig.LookupKeyBindings = l =>

{

var combinations = KeyBindingStore.GetReadableKeyCombinationsFor(l);

if (combinations.Count == 0)

return ToastStrings.NoKeyBound;

return string.Join(" / ", combinations);

};

Container logoContainer;

BackButton.Receptor receptor;

dependencies.CacheAs(idleTracker = new GameIdleTracker(6000));

var sessionIdleTracker = new GameIdleTracker(300000);

sessionIdleTracker.IsIdle.BindValueChanged(idle =>

{

if (idle.NewValue)

SessionStatics.ResetAfterInactivity();

});

Add(sessionIdleTracker);

AddRange(new Drawable[]

{

new VolumeControlReceptor

{

RelativeSizeAxes = Axes.Both,

ActionRequested = action => volume.Adjust(action),

ScrollActionRequested = (action, amount, isPrecise) => volume.Adjust(action, amount, isPrecise),

},

ScreenOffsetContainer = new Container

{

RelativeSizeAxes = Axes.Both,

Children = new Drawable[]

{

ScreenContainer = new ScalingContainer(ScalingMode.ExcludeOverlays)

{

RelativeSizeAxes = Axes.Both,

Anchor = Anchor.Centre,

Origin = Anchor.Centre,

Children = new Drawable[]

{

receptor = new BackButton.Receptor(),

ScreenStack = new OsuScreenStack { RelativeSizeAxes = Axes.Both },

BackButton = new BackButton(receptor)

{

Anchor = Anchor.BottomLeft,

Origin = Anchor.BottomLeft,

Action = () =>

{

if (!(ScreenStack.CurrentScreen is IOsuScreen currentScreen))

return;

if (!((Drawable)currentScreen).IsLoaded || (currentScreen.AllowBackButton && !currentScreen.OnBackButton()))

ScreenStack.Exit();

}

},

logoContainer = new Container { RelativeSizeAxes = Axes.Both },

}

},

}

},

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 },

}

},

topMostOverlayContent = new Container { RelativeSizeAxes = Axes.Both },

idleTracker,

new ConfineMouseTracker()

});

ScreenStack.ScreenPushed += screenPushed;

ScreenStack.ScreenExited += screenExited;

loadComponentSingleFile(fpsCounter = new FPSCounter

{

Anchor = Anchor.BottomRight,

Origin = Anchor.BottomRight,

Margin = new MarginPadding(5),

}, topMostOverlayContent.Add);

if (!IsDeployedBuild)

{

dependencies.Cache(versionManager = new VersionManager { Depth = int.MinValue });

loadComponentSingleFile(versionManager, ScreenContainer.Add);

}

loadComponentSingleFile(osuLogo, _ =>

{