osu/osu.Game/OsuGameBase.cs

368 lines
14 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 09:19:50 +00:00
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
2018-04-13 09:19:50 +00:00
using osu.Framework.Allocation;
using osu.Framework.Audio;
2019-02-21 10:04:31 +00:00
using osu.Framework.Bindables;
2019-06-20 03:48:45 +00:00
using osu.Framework.Development;
2018-04-13 09:19:50 +00:00
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.IO.Stores;
using osu.Framework.Platform;
using osu.Game.Beatmaps;
using osu.Game.Configuration;
using osu.Game.Graphics;
using osu.Game.Graphics.Cursor;
using osu.Game.Online.API;
using osu.Framework.Graphics.Performance;
using osu.Framework.Graphics.Textures;
using osu.Framework.Input;
2018-04-13 09:19:50 +00:00
using osu.Framework.Logging;
using osu.Game.Audio;
2018-04-13 09:19:50 +00:00
using osu.Game.Database;
using osu.Game.Input;
using osu.Game.Input.Bindings;
using osu.Game.IO;
using osu.Game.Resources;
2018-04-13 09:19:50 +00:00
using osu.Game.Rulesets;
2019-05-15 04:00:11 +00:00
using osu.Game.Rulesets.Mods;
2018-11-28 07:12:57 +00:00
using osu.Game.Scoring;
2018-04-13 09:19:50 +00:00
using osu.Game.Skinning;
2018-11-20 07:51:59 +00:00
using osuTK.Input;
2018-04-13 09:19:50 +00:00
namespace osu.Game
{
/// <summary>
/// The most basic <see cref="Game"/> that can be used to host osu! components and systems.
/// Unlike <see cref="OsuGame"/>, this class will not load any kind of UI, allowing it to be used
/// for provide dependencies to test cases without interfering with them.
/// </summary>
public class OsuGameBase : Framework.Game, ICanAcceptFiles
{
2019-06-03 04:16:05 +00:00
public const string CLIENT_STREAM_NAME = "lazer";
public const int SAMPLE_CONCURRENCY = 6;
2018-04-13 09:19:50 +00:00
protected OsuConfigManager LocalConfig;
protected BeatmapManager BeatmapManager;
protected ScoreManager ScoreManager;
2018-04-13 09:19:50 +00:00
protected SkinManager SkinManager;
protected RulesetStore RulesetStore;
protected FileStore FileStore;
protected KeyBindingStore KeyBindingStore;
protected SettingsStore SettingsStore;
2018-06-11 06:07:42 +00:00
protected RulesetConfigCache RulesetConfigCache;
2019-09-25 06:00:08 +00:00
protected IAPIProvider API;
2018-12-06 03:17:08 +00:00
protected MenuCursorContainer MenuCursorContainer;
2018-04-13 09:19:50 +00:00
private Container content;
protected override Container<Drawable> Content => content;
2019-09-25 06:00:08 +00:00
protected Storage Storage { get; set; }
2019-05-15 04:00:11 +00:00
[Cached]
[Cached(typeof(IBindable<RulesetInfo>))]
protected readonly Bindable<RulesetInfo> Ruleset = new Bindable<RulesetInfo>();
// todo: move this to SongSelect once Screen has the ability to unsuspend.
[Cached]
2019-12-13 11:13:53 +00:00
[Cached(typeof(IBindable<IReadOnlyList<Mod>>))]
2019-12-13 12:45:38 +00:00
protected readonly Bindable<IReadOnlyList<Mod>> SelectedMods = new Bindable<IReadOnlyList<Mod>>(Array.Empty<Mod>());
2019-02-01 06:42:15 +00:00
/// <summary>
/// Mods available for the current <see cref="Ruleset"/>.
/// </summary>
public readonly Bindable<Dictionary<ModType, IReadOnlyList<Mod>>> AvailableMods = new Bindable<Dictionary<ModType, IReadOnlyList<Mod>>>();
2019-11-12 09:45:42 +00:00
protected Bindable<WorkingBeatmap> Beatmap { get; private set; } // cached via load() method
2018-04-13 09:19:50 +00:00
private Bindable<bool> fpsDisplayVisible;
2019-03-01 11:15:09 +00:00
public virtual Version AssemblyVersion => Assembly.GetEntryAssembly()?.GetName().Version ?? new Version();
2018-04-13 09:19:50 +00:00
public bool IsDeployedBuild => AssemblyVersion.Major > 0;
2018-04-13 09:19:50 +00:00
2020-03-05 05:46:07 +00:00
public virtual string Version
2018-04-13 09:19:50 +00:00
{
get
{
if (!IsDeployedBuild)
2019-06-20 03:48:45 +00:00
return @"local " + (DebugUtils.IsDebugBuild ? @"debug" : @"release");
2018-04-13 09:19:50 +00:00
var version = AssemblyVersion;
return $@"{version.Major}.{version.Minor}.{version.Build}";
2018-04-13 09:19:50 +00:00
}
}
public OsuGameBase()
{
Name = @"osu!lazer";
}
private DependencyContainer dependencies;
2018-07-11 08:07:14 +00:00
protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent) =>
dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
2018-04-13 09:19:50 +00:00
protected DatabaseContextFactory ContextFactory;
2018-04-13 09:19:50 +00:00
protected override UserInputManager CreateUserInputManager() => new OsuUserInputManager();
2018-04-13 09:19:50 +00:00
[BackgroundDependencyLoader]
private void load()
{
Resources.AddStore(new DllResourceStore(OsuResources.ResourceAssembly));
2018-06-04 11:01:55 +00:00
dependencies.Cache(ContextFactory = new DatabaseContextFactory(Storage));
2018-04-13 09:19:50 +00:00
dependencies.CacheAs(Storage);
var largeStore = new LargeTextureStore(Host.CreateTextureLoaderStore(new NamespacedResourceStore<byte[]>(Resources, @"Textures")));
largeStore.AddStore(Host.CreateTextureLoaderStore(new OnlineStore()));
dependencies.Cache(largeStore);
2018-04-13 09:19:50 +00:00
dependencies.CacheAs(this);
dependencies.Cache(LocalConfig);
2019-11-28 17:15:13 +00:00
AddFont(Resources, @"Fonts/osuFont");
2020-03-03 09:04:12 +00:00
AddFont(Resources, @"Fonts/Torus-Regular");
AddFont(Resources, @"Fonts/Torus-Light");
AddFont(Resources, @"Fonts/Torus-SemiBold");
AddFont(Resources, @"Fonts/Torus-Bold");
2020-03-03 09:04:12 +00:00
2020-03-08 05:43:27 +00:00
AddFont(Resources, @"Fonts/Noto-Basic");
AddFont(Resources, @"Fonts/Noto-Hangul");
AddFont(Resources, @"Fonts/Noto-CJK-Basic");
AddFont(Resources, @"Fonts/Noto-CJK-Compatibility");
2019-11-28 17:15:13 +00:00
AddFont(Resources, @"Fonts/Venera-Light");
2020-03-04 02:46:48 +00:00
AddFont(Resources, @"Fonts/Venera-Bold");
AddFont(Resources, @"Fonts/Venera-Black");
2018-04-13 09:19:50 +00:00
Audio.Samples.PlaybackConcurrency = SAMPLE_CONCURRENCY;
runMigrations();
dependencies.Cache(SkinManager = new SkinManager(Storage, ContextFactory, Host, Audio, new NamespacedResourceStore<byte[]>(Resources, "Skins/Legacy")));
dependencies.CacheAs<ISkinSource>(SkinManager);
2019-09-25 06:00:08 +00:00
if (API == null) API = new APIAccess(LocalConfig);
2019-09-25 06:00:08 +00:00
dependencies.CacheAs(API);
var defaultBeatmap = new DummyWorkingBeatmap(Audio, Textures);
2018-12-25 09:34:45 +00:00
dependencies.Cache(RulesetStore = new RulesetStore(ContextFactory, Storage));
dependencies.Cache(FileStore = new FileStore(ContextFactory, Storage));
// ordering is important here to ensure foreign keys rules are not broken in ModelStore.Cleanup()
dependencies.Cache(ScoreManager = new ScoreManager(RulesetStore, () => BeatmapManager, Storage, API, ContextFactory, Host));
dependencies.Cache(BeatmapManager = new BeatmapManager(Storage, ContextFactory, RulesetStore, API, Audio, Host, defaultBeatmap));
// this should likely be moved to ArchiveModelManager when another case appers where it is necessary
// to have inter-dependent model managers. this could be obtained with an IHasForeign<T> interface to
// allow lookups to be done on the child (ScoreManager in this case) to perform the cascading delete.
List<ScoreInfo> getBeatmapScores(BeatmapSetInfo set)
{
var beatmapIds = BeatmapManager.QueryBeatmaps(b => b.BeatmapSetInfoID == set.ID).Select(b => b.ID).ToList();
return ScoreManager.QueryScores(s => beatmapIds.Contains(s.Beatmap.ID)).ToList();
}
BeatmapManager.ItemRemoved += i => ScoreManager.Delete(getBeatmapScores(i), true);
BeatmapManager.ItemAdded += i => ScoreManager.Undelete(getBeatmapScores(i), true);
dependencies.Cache(KeyBindingStore = new KeyBindingStore(ContextFactory, RulesetStore));
dependencies.Cache(SettingsStore = new SettingsStore(ContextFactory));
dependencies.Cache(RulesetConfigCache = new RulesetConfigCache(SettingsStore));
2019-09-23 05:15:27 +00:00
dependencies.Cache(new SessionStatics());
dependencies.Cache(new OsuColour());
fileImporters.Add(BeatmapManager);
fileImporters.Add(ScoreManager);
fileImporters.Add(SkinManager);
2018-04-13 09:19:50 +00:00
// tracks play so loud our samples can't keep up.
// this adds a global reduction of track volume for the time being.
Audio.Tracks.AddAdjustment(AdjustableProperty.Volume, new BindableDouble(0.8));
2018-04-13 09:19:50 +00:00
2019-11-12 09:45:42 +00:00
Beatmap = new NonNullableBindable<WorkingBeatmap>(defaultBeatmap);
// ScheduleAfterChildren is safety against something in the current frame accessing the previous beatmap's track
// and potentially causing a reload of it after just unloading.
2020-03-05 07:58:07 +00:00
// Note that the reason for this being added *has* been resolved, so it may be feasible to removed this if required.
2019-11-12 09:45:42 +00:00
Beatmap.BindValueChanged(b => ScheduleAfterChildren(() =>
{
// compare to last beatmap as sometimes the two may share a track representation (optimisation, see WorkingBeatmap.TransferTo)
if (b.OldValue?.TrackLoaded == true && b.OldValue?.Track != b.NewValue?.Track)
b.OldValue.RecycleTrack();
}));
2019-02-01 06:42:15 +00:00
2019-11-12 09:45:42 +00:00
dependencies.CacheAs<IBindable<WorkingBeatmap>>(Beatmap);
dependencies.CacheAs(Beatmap);
2018-04-13 09:19:50 +00:00
FileStore.Cleanup();
2019-09-25 06:00:08 +00:00
if (API is APIAccess apiAcces)
AddInternal(apiAcces);
AddInternal(RulesetConfigCache);
GlobalActionContainer globalBinding;
MenuCursorContainer = new MenuCursorContainer { RelativeSizeAxes = Axes.Both };
MenuCursorContainer.Child = globalBinding = new GlobalActionContainer(this)
{
RelativeSizeAxes = Axes.Both,
Child = content = new OsuTooltipContainer(MenuCursorContainer.Cursor) { RelativeSizeAxes = Axes.Both }
};
base.Content.Add(CreateScalingContainer().WithChild(MenuCursorContainer));
KeyBindingStore.Register(globalBinding);
dependencies.Cache(globalBinding);
PreviewTrackManager previewTrackManager;
dependencies.Cache(previewTrackManager = new PreviewTrackManager());
Add(previewTrackManager);
Ruleset.BindValueChanged(onRulesetChanged);
}
private void onRulesetChanged(ValueChangedEvent<RulesetInfo> r)
{
var dict = new Dictionary<ModType, IReadOnlyList<Mod>>();
if (r.NewValue?.Available == true)
{
foreach (ModType type in Enum.GetValues(typeof(ModType)))
dict[type] = r.NewValue.CreateInstance().GetModsFor(type).ToList();
}
if (!SelectedMods.Disabled)
SelectedMods.Value = Array.Empty<Mod>();
AvailableMods.Value = dict;
2018-04-13 09:19:50 +00:00
}
protected virtual Container CreateScalingContainer() => new DrawSizePreservingFillContainer();
2018-05-23 05:56:40 +00:00
protected override void LoadComplete()
{
base.LoadComplete();
// TODO: This is temporary until we reimplement the local FPS display.
// It's just to allow end-users to access the framework FPS display without knowing the shortcut key.
fpsDisplayVisible = LocalConfig.GetBindable<bool>(OsuSetting.ShowFpsDisplay);
fpsDisplayVisible.ValueChanged += visible => { FrameStatistics.Value = visible.NewValue ? FrameStatisticsMode.Minimal : FrameStatisticsMode.None; };
2018-05-23 05:56:40 +00:00
fpsDisplayVisible.TriggerChange();
FrameStatistics.ValueChanged += e => fpsDisplayVisible.Value = e.NewValue != FrameStatisticsMode.None;
2018-05-23 05:56:40 +00:00
}
2018-04-13 09:19:50 +00:00
private void runMigrations()
{
try
{
using (var db = ContextFactory.GetForWrite(false))
2018-04-13 09:19:50 +00:00
db.Context.Migrate();
}
catch (Exception e)
2018-04-13 09:19:50 +00:00
{
Logger.Error(e.InnerException ?? e, "Migration failed! We'll be starting with a fresh database.", LoggingTarget.Database);
// if we failed, let's delete the database and start fresh.
// todo: we probably want a better (non-destructive) migrations/recovery process at a later point than this.
ContextFactory.ResetDatabase();
2018-07-24 10:11:20 +00:00
Logger.Log("Database purged successfully.", LoggingTarget.Database);
2018-04-13 09:19:50 +00:00
// only run once more, then hard bail.
using (var db = ContextFactory.GetForWrite(false))
2018-04-13 09:19:50 +00:00
db.Context.Migrate();
}
}
public override void SetHost(GameHost host)
{
base.SetHost(host);
2019-09-25 06:00:08 +00:00
2020-05-08 10:08:43 +00:00
if (Storage == null) // may be non-null for certain tests
Storage = new OsuStorage(host);
2019-09-25 06:00:08 +00:00
if (LocalConfig == null)
LocalConfig = new OsuConfigManager(Storage);
2018-04-13 09:19:50 +00:00
}
private readonly List<ICanAcceptFiles> fileImporters = new List<ICanAcceptFiles>();
public async Task Import(params string[] paths)
2018-04-13 09:19:50 +00:00
{
2018-09-26 09:44:03 +00:00
var extension = Path.GetExtension(paths.First())?.ToLowerInvariant();
2018-04-13 09:19:50 +00:00
foreach (var importer in fileImporters)
2019-11-11 11:53:22 +00:00
{
2019-01-04 04:29:37 +00:00
if (importer.HandledExtensions.Contains(extension))
await importer.Import(paths);
2019-11-11 11:53:22 +00:00
}
2018-04-13 09:19:50 +00:00
}
public string[] HandledExtensions => fileImporters.SelectMany(i => i.HandledExtensions).ToArray();
protected override void Dispose(bool isDisposing)
{
base.Dispose(isDisposing);
RulesetStore?.Dispose();
2020-05-11 12:37:07 +00:00
ContextFactory.FlushConnections();
}
private class OsuUserInputManager : UserInputManager
{
2020-01-22 14:04:37 +00:00
protected override MouseButtonEventManager CreateButtonEventManagerFor(MouseButton button)
{
switch (button)
{
case MouseButton.Right:
return new RightMouseManager(button);
}
2020-01-22 14:04:37 +00:00
return base.CreateButtonEventManagerFor(button);
}
private class RightMouseManager : MouseButtonEventManager
{
public RightMouseManager(MouseButton button)
: base(button)
{
}
public override bool EnableDrag => true; // allow right-mouse dragging for absolute scroll in scroll containers.
public override bool EnableClick => false;
public override bool ChangeFocusOnClick => false;
}
}
2020-05-11 12:37:07 +00:00
public void Migrate(string path)
{
ContextFactory.FlushConnections();
(Storage as OsuStorage)?.Migrate(path);
}
2018-04-13 09:19:50 +00:00
}
}