2019-01-24 08:43:03 +00:00
|
|
|
// 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;
|
2019-05-28 09:59:21 +00:00
|
|
|
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;
|
2020-07-29 03:39:18 +00:00
|
|
|
using osu.Framework.Extensions;
|
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;
|
2018-07-09 06:26:22 +00:00
|
|
|
using osu.Framework.Input;
|
2018-04-13 09:19:50 +00:00
|
|
|
using osu.Framework.Logging;
|
2018-05-09 11:52:46 +00:00
|
|
|
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;
|
2020-10-22 04:41:54 +00:00
|
|
|
using osu.Game.Online.Spectator;
|
2020-08-06 10:01:23 +00:00
|
|
|
using osu.Game.Overlays;
|
2019-12-28 13:13:18 +00:00
|
|
|
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;
|
2020-08-03 09:48:10 +00:00
|
|
|
using RuntimeInfo = osu.Framework.RuntimeInfo;
|
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";
|
|
|
|
|
2020-03-21 17:16:28 +00:00
|
|
|
public const int SAMPLE_CONCURRENCY = 6;
|
|
|
|
|
2018-04-13 09:19:50 +00:00
|
|
|
protected OsuConfigManager LocalConfig;
|
|
|
|
|
|
|
|
protected BeatmapManager BeatmapManager;
|
|
|
|
|
2018-11-28 07:47:10 +00:00
|
|
|
protected ScoreManager ScoreManager;
|
|
|
|
|
2020-08-28 10:16:46 +00:00
|
|
|
protected BeatmapDifficultyManager DifficultyManager;
|
|
|
|
|
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
|
|
|
|
2020-10-22 04:41:54 +00:00
|
|
|
private SpectatorStreamingClient spectatorStreaming;
|
|
|
|
|
2018-05-25 19:13:40 +00:00
|
|
|
protected MenuCursorContainer MenuCursorContainer;
|
2018-04-13 09:19:50 +00:00
|
|
|
|
2020-08-06 10:01:23 +00:00
|
|
|
protected MusicController MusicController;
|
|
|
|
|
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
|
|
|
|
2019-12-12 09:53:25 +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
|
|
|
|
2020-07-29 03:39:18 +00:00
|
|
|
/// <summary>
|
|
|
|
/// MD5 representation of the game executable.
|
|
|
|
/// </summary>
|
|
|
|
public string VersionHash { get; private set; }
|
|
|
|
|
2019-03-01 10:59:39 +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
|
|
|
|
2019-03-01 10:59:39 +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
|
|
|
|
2020-05-12 03:39:52 +00:00
|
|
|
private DatabaseContextFactory contextFactory;
|
2018-04-13 09:19:50 +00:00
|
|
|
|
2018-07-09 06:26:22 +00:00
|
|
|
protected override UserInputManager CreateUserInputManager() => new OsuUserInputManager();
|
|
|
|
|
2018-04-13 09:19:50 +00:00
|
|
|
[BackgroundDependencyLoader]
|
|
|
|
private void load()
|
|
|
|
{
|
2020-08-03 09:48:10 +00:00
|
|
|
try
|
|
|
|
{
|
|
|
|
using (var str = File.OpenRead(typeof(OsuGameBase).Assembly.Location))
|
|
|
|
VersionHash = str.ComputeMD5Hash();
|
|
|
|
}
|
|
|
|
catch
|
|
|
|
{
|
|
|
|
// special case for android builds, which can't read DLLs from a packed apk.
|
|
|
|
// should eventually be handled in a better way.
|
|
|
|
VersionHash = $"{Version}-{RuntimeInfo.OS}".ComputeMD5Hash();
|
|
|
|
}
|
2020-07-29 03:39:18 +00:00
|
|
|
|
2019-12-28 13:13:18 +00:00
|
|
|
Resources.AddStore(new DllResourceStore(OsuResources.ResourceAssembly));
|
2018-06-04 11:01:55 +00:00
|
|
|
|
2020-05-12 03:39:52 +00:00
|
|
|
dependencies.Cache(contextFactory = new DatabaseContextFactory(Storage));
|
2018-04-13 09:19:50 +00:00
|
|
|
|
2020-05-04 08:01:05 +00:00
|
|
|
dependencies.CacheAs(Storage);
|
|
|
|
|
2019-01-25 02:41:44 +00:00
|
|
|
var largeStore = new LargeTextureStore(Host.CreateTextureLoaderStore(new NamespacedResourceStore<byte[]>(Resources, @"Textures")));
|
|
|
|
largeStore.AddStore(Host.CreateTextureLoaderStore(new OnlineStore()));
|
2018-09-08 17:41:47 +00:00
|
|
|
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");
|
2020-03-13 04:31:59 +00:00
|
|
|
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");
|
2020-07-15 04:35:40 +00:00
|
|
|
AddFont(Resources, @"Fonts/Noto-Thai");
|
2020-03-08 05:43:27 +00:00
|
|
|
|
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
|
|
|
|
2020-03-21 17:16:28 +00:00
|
|
|
Audio.Samples.PlaybackConcurrency = SAMPLE_CONCURRENCY;
|
|
|
|
|
2018-09-01 08:39:54 +00:00
|
|
|
runMigrations();
|
|
|
|
|
2020-05-12 03:39:52 +00:00
|
|
|
dependencies.Cache(SkinManager = new SkinManager(Storage, contextFactory, Host, Audio, new NamespacedResourceStore<byte[]>(Resources, "Skins/Legacy")));
|
2018-09-01 08:39:54 +00:00
|
|
|
dependencies.CacheAs<ISkinSource>(SkinManager);
|
|
|
|
|
2020-10-22 04:41:54 +00:00
|
|
|
dependencies.CacheAs(API ??= new APIAccess(LocalConfig));
|
2018-09-01 08:39:54 +00:00
|
|
|
|
2020-10-22 04:41:54 +00:00
|
|
|
dependencies.CacheAs(spectatorStreaming = new SpectatorStreamingClient());
|
2018-09-01 08:39:54 +00:00
|
|
|
|
2019-05-31 05:51:12 +00:00
|
|
|
var defaultBeatmap = new DummyWorkingBeatmap(Audio, Textures);
|
2018-12-25 09:34:45 +00:00
|
|
|
|
2020-05-12 03:39:52 +00:00
|
|
|
dependencies.Cache(RulesetStore = new RulesetStore(contextFactory, Storage));
|
|
|
|
dependencies.Cache(FileStore = new FileStore(contextFactory, Storage));
|
2019-05-09 06:15:28 +00:00
|
|
|
|
|
|
|
// ordering is important here to ensure foreign keys rules are not broken in ModelStore.Cleanup()
|
2020-08-28 12:34:34 +00:00
|
|
|
dependencies.Cache(ScoreManager = new ScoreManager(RulesetStore, () => BeatmapManager, Storage, API, contextFactory, Host, () => DifficultyManager, LocalConfig));
|
2020-09-09 11:11:29 +00:00
|
|
|
dependencies.Cache(BeatmapManager = new BeatmapManager(Storage, contextFactory, RulesetStore, API, Audio, Host, defaultBeatmap, true));
|
2019-05-09 06:15:28 +00:00
|
|
|
|
|
|
|
// 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();
|
|
|
|
}
|
|
|
|
|
2020-05-19 07:44:22 +00:00
|
|
|
BeatmapManager.ItemRemoved.BindValueChanged(i =>
|
|
|
|
{
|
|
|
|
if (i.NewValue.TryGetTarget(out var item))
|
|
|
|
ScoreManager.Delete(getBeatmapScores(item), true);
|
|
|
|
});
|
|
|
|
|
2020-05-27 07:08:47 +00:00
|
|
|
BeatmapManager.ItemUpdated.BindValueChanged(i =>
|
2020-05-19 07:44:22 +00:00
|
|
|
{
|
|
|
|
if (i.NewValue.TryGetTarget(out var item))
|
|
|
|
ScoreManager.Undelete(getBeatmapScores(item), true);
|
|
|
|
});
|
2019-05-09 06:15:28 +00:00
|
|
|
|
2020-08-28 10:16:46 +00:00
|
|
|
dependencies.Cache(DifficultyManager = new BeatmapDifficultyManager());
|
|
|
|
AddInternal(DifficultyManager);
|
2020-07-21 14:13:04 +00:00
|
|
|
|
2020-05-12 03:39:52 +00:00
|
|
|
dependencies.Cache(KeyBindingStore = new KeyBindingStore(contextFactory, RulesetStore));
|
|
|
|
dependencies.Cache(SettingsStore = new SettingsStore(contextFactory));
|
2018-09-01 08:39:54 +00:00
|
|
|
dependencies.Cache(RulesetConfigCache = new RulesetConfigCache(SettingsStore));
|
2019-09-23 05:15:27 +00:00
|
|
|
dependencies.Cache(new SessionStatics());
|
2018-09-01 08:39:54 +00:00
|
|
|
dependencies.Cache(new OsuColour());
|
|
|
|
|
2020-10-02 07:08:11 +00:00
|
|
|
RegisterImportHandler(BeatmapManager);
|
|
|
|
RegisterImportHandler(ScoreManager);
|
|
|
|
RegisterImportHandler(SkinManager);
|
2018-09-01 08:39:54 +00:00
|
|
|
|
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.
|
2019-05-28 08:06:01 +00:00
|
|
|
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);
|
2020-03-04 10:07:34 +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();
|
|
|
|
|
2020-10-22 05:54:27 +00:00
|
|
|
// add api components to hierarchy.
|
2020-05-28 10:05:35 +00:00
|
|
|
if (API is APIAccess apiAccess)
|
|
|
|
AddInternal(apiAccess);
|
2020-10-22 05:54:27 +00:00
|
|
|
AddInternal(spectatorStreaming);
|
|
|
|
|
2019-09-05 16:13:58 +00:00
|
|
|
AddInternal(RulesetConfigCache);
|
2018-04-21 19:10:06 +00:00
|
|
|
|
2018-05-25 19:13:40 +00:00
|
|
|
MenuCursorContainer = new MenuCursorContainer { RelativeSizeAxes = Axes.Both };
|
2020-09-08 09:36:11 +00:00
|
|
|
|
|
|
|
GlobalActionContainer globalBindings;
|
|
|
|
|
|
|
|
MenuCursorContainer.Child = globalBindings = new GlobalActionContainer(this)
|
2018-04-21 19:10:06 +00:00
|
|
|
{
|
|
|
|
RelativeSizeAxes = Axes.Both,
|
2018-05-25 19:13:40 +00:00
|
|
|
Child = content = new OsuTooltipContainer(MenuCursorContainer.Cursor) { RelativeSizeAxes = Axes.Both }
|
2018-04-21 19:10:06 +00:00
|
|
|
};
|
|
|
|
|
2019-11-11 04:58:35 +00:00
|
|
|
base.Content.Add(CreateScalingContainer().WithChild(MenuCursorContainer));
|
2018-04-21 19:10:06 +00:00
|
|
|
|
2020-09-08 09:36:11 +00:00
|
|
|
KeyBindingStore.Register(globalBindings);
|
|
|
|
dependencies.Cache(globalBindings);
|
2018-05-09 11:52:46 +00:00
|
|
|
|
|
|
|
PreviewTrackManager previewTrackManager;
|
|
|
|
dependencies.Cache(previewTrackManager = new PreviewTrackManager());
|
|
|
|
Add(previewTrackManager);
|
2019-12-12 09:53:25 +00:00
|
|
|
|
2020-08-06 10:01:23 +00:00
|
|
|
AddInternal(MusicController = new MusicController());
|
|
|
|
dependencies.CacheAs(MusicController);
|
|
|
|
|
2019-12-12 09:53:25 +00:00
|
|
|
Ruleset.BindValueChanged(onRulesetChanged);
|
|
|
|
}
|
|
|
|
|
|
|
|
private void onRulesetChanged(ValueChangedEvent<RulesetInfo> r)
|
|
|
|
{
|
|
|
|
var dict = new Dictionary<ModType, IReadOnlyList<Mod>>();
|
|
|
|
|
2019-12-14 17:36:49 +00:00
|
|
|
if (r.NewValue?.Available == true)
|
|
|
|
{
|
|
|
|
foreach (ModType type in Enum.GetValues(typeof(ModType)))
|
|
|
|
dict[type] = r.NewValue.CreateInstance().GetModsFor(type).ToList();
|
|
|
|
}
|
2019-12-12 09:53:25 +00:00
|
|
|
|
2019-12-13 15:42:31 +00:00
|
|
|
if (!SelectedMods.Disabled)
|
|
|
|
SelectedMods.Value = Array.Empty<Mod>();
|
2019-12-12 09:53:25 +00:00
|
|
|
AvailableMods.Value = dict;
|
2018-04-13 09:19:50 +00:00
|
|
|
}
|
|
|
|
|
2019-11-11 04:58:35 +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);
|
2019-05-14 04:13:51 +00:00
|
|
|
fpsDisplayVisible.ValueChanged += visible => { FrameStatistics.Value = visible.NewValue ? FrameStatisticsMode.Minimal : FrameStatisticsMode.None; };
|
2018-05-23 05:56:40 +00:00
|
|
|
fpsDisplayVisible.TriggerChange();
|
2019-05-14 04:13:51 +00:00
|
|
|
|
|
|
|
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
|
|
|
|
{
|
2020-05-12 03:39:52 +00:00
|
|
|
using (var db = contextFactory.GetForWrite(false))
|
2018-04-13 09:19:50 +00:00
|
|
|
db.Context.Migrate();
|
|
|
|
}
|
2018-06-03 17:07:02 +00:00
|
|
|
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.
|
2020-05-12 03:39:52 +00:00
|
|
|
contextFactory.ResetDatabase();
|
2018-06-03 17:07:02 +00:00
|
|
|
|
2018-07-24 10:11:20 +00:00
|
|
|
Logger.Log("Database purged successfully.", LoggingTarget.Database);
|
2018-04-13 09:19:50 +00:00
|
|
|
|
2018-06-03 17:07:02 +00:00
|
|
|
// only run once more, then hard bail.
|
2020-05-12 03:39:52 +00:00
|
|
|
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-06-03 07:48:44 +00:00
|
|
|
// may be non-null for certain tests
|
2020-07-01 08:12:07 +00:00
|
|
|
Storage ??= host.Storage;
|
2019-09-25 06:00:08 +00:00
|
|
|
|
2020-06-03 07:48:44 +00:00
|
|
|
LocalConfig ??= new OsuConfigManager(Storage);
|
2018-04-13 09:19:50 +00:00
|
|
|
}
|
|
|
|
|
2020-07-01 08:12:07 +00:00
|
|
|
protected override Storage CreateStorage(GameHost host, Storage defaultStorage) => new OsuStorage(host, defaultStorage);
|
|
|
|
|
2018-04-13 09:19:50 +00:00
|
|
|
private readonly List<ICanAcceptFiles> fileImporters = new List<ICanAcceptFiles>();
|
|
|
|
|
2020-10-02 07:08:11 +00:00
|
|
|
/// <summary>
|
2020-10-02 07:14:21 +00:00
|
|
|
/// Register a global handler for file imports. Most recently registered will have precedence.
|
2020-10-02 07:08:11 +00:00
|
|
|
/// </summary>
|
|
|
|
/// <param name="handler">The handler to register.</param>
|
2020-10-02 07:14:21 +00:00
|
|
|
public void RegisterImportHandler(ICanAcceptFiles handler) => fileImporters.Insert(0, handler);
|
2020-10-02 07:08:11 +00:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Unregister a global handler for file imports.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="handler">The previously registered handler.</param>
|
|
|
|
public void UnregisterImportHandler(ICanAcceptFiles handler) => fileImporters.Remove(handler);
|
2018-04-13 09:19:50 +00:00
|
|
|
|
2019-05-28 09:59:21 +00:00
|
|
|
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))
|
2019-05-28 09:59:21 +00:00
|
|
|
await importer.Import(paths);
|
2019-11-11 11:53:22 +00:00
|
|
|
}
|
2018-04-13 09:19:50 +00:00
|
|
|
}
|
|
|
|
|
2020-10-02 07:17:10 +00:00
|
|
|
public IEnumerable<string> HandledExtensions => fileImporters.SelectMany(i => i.HandledExtensions);
|
2018-05-28 08:55:41 +00:00
|
|
|
|
2019-10-15 07:14:06 +00:00
|
|
|
protected override void Dispose(bool isDisposing)
|
|
|
|
{
|
|
|
|
base.Dispose(isDisposing);
|
2020-10-19 10:03:22 +00:00
|
|
|
|
2019-10-15 07:14:06 +00:00
|
|
|
RulesetStore?.Dispose();
|
2020-05-22 14:26:37 +00:00
|
|
|
BeatmapManager?.Dispose();
|
2020-10-19 10:03:22 +00:00
|
|
|
LocalConfig?.Dispose();
|
2020-05-11 12:37:07 +00:00
|
|
|
|
2020-05-12 03:39:52 +00:00
|
|
|
contextFactory.FlushConnections();
|
2019-10-15 07:14:06 +00:00
|
|
|
}
|
|
|
|
|
2018-07-09 06:26:22 +00:00
|
|
|
private class OsuUserInputManager : UserInputManager
|
|
|
|
{
|
2020-01-22 14:04:37 +00:00
|
|
|
protected override MouseButtonEventManager CreateButtonEventManagerFor(MouseButton button)
|
2018-07-09 06:26:22 +00:00
|
|
|
{
|
|
|
|
switch (button)
|
|
|
|
{
|
|
|
|
case MouseButton.Right:
|
|
|
|
return new RightMouseManager(button);
|
|
|
|
}
|
|
|
|
|
2020-01-22 14:04:37 +00:00
|
|
|
return base.CreateButtonEventManagerFor(button);
|
2018-07-09 06:26:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2020-05-12 03:39:52 +00:00
|
|
|
contextFactory.FlushConnections();
|
2020-07-01 20:57:16 +00:00
|
|
|
(Storage as OsuStorage)?.Migrate(Host.GetStorage(path));
|
2020-05-11 12:37:07 +00:00
|
|
|
}
|
2018-04-13 09:19:50 +00:00
|
|
|
}
|
|
|
|
}
|