mirror of
https://github.com/ppy/osu.git
synced 2024-12-25 17:32:55 +08:00
187 lines
7.5 KiB
C#
187 lines
7.5 KiB
C#
// 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.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using osu.Framework;
|
|
using osu.Framework.Logging;
|
|
using osu.Framework.Platform;
|
|
|
|
#nullable enable
|
|
|
|
namespace osu.Game.Rulesets
|
|
{
|
|
public abstract class RulesetStore : IDisposable, IRulesetStore
|
|
{
|
|
private const string ruleset_library_prefix = @"osu.Game.Rulesets";
|
|
|
|
protected readonly Dictionary<Assembly, Type> LoadedAssemblies = new Dictionary<Assembly, Type>();
|
|
|
|
/// <summary>
|
|
/// All available rulesets.
|
|
/// </summary>
|
|
public abstract IEnumerable<RulesetInfo> AvailableRulesets { get; }
|
|
|
|
protected RulesetStore(Storage? storage = null)
|
|
{
|
|
// On android in release configuration assemblies are loaded from the apk directly into memory.
|
|
// We cannot read assemblies from cwd, so should check loaded assemblies instead.
|
|
loadFromAppDomain();
|
|
|
|
// This null check prevents Android from attempting to load the rulesets from disk,
|
|
// as the underlying path "AppContext.BaseDirectory", despite being non-nullable, it returns null on android.
|
|
// See https://github.com/xamarin/xamarin-android/issues/3489.
|
|
if (RuntimeInfo.StartupDirectory != null)
|
|
loadFromDisk();
|
|
|
|
// the event handler contains code for resolving dependency on the game assembly for rulesets located outside the base game directory.
|
|
// It needs to be attached to the assembly lookup event before the actual call to loadUserRulesets() else rulesets located out of the base game directory will fail
|
|
// to load as unable to locate the game core assembly.
|
|
AppDomain.CurrentDomain.AssemblyResolve += resolveRulesetDependencyAssembly;
|
|
|
|
var rulesetStorage = storage?.GetStorageForDirectory(@"rulesets");
|
|
if (rulesetStorage != null)
|
|
loadUserRulesets(rulesetStorage);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieve a ruleset using a known ID.
|
|
/// </summary>
|
|
/// <param name="id">The ruleset's internal ID.</param>
|
|
/// <returns>A ruleset, if available, else null.</returns>
|
|
public RulesetInfo? GetRuleset(int id) => AvailableRulesets.FirstOrDefault(r => r.OnlineID == id);
|
|
|
|
/// <summary>
|
|
/// Retrieve a ruleset using a known short name.
|
|
/// </summary>
|
|
/// <param name="shortName">The ruleset's short name.</param>
|
|
/// <returns>A ruleset, if available, else null.</returns>
|
|
public RulesetInfo? GetRuleset(string shortName) => AvailableRulesets.FirstOrDefault(r => r.ShortName == shortName);
|
|
|
|
private Assembly? resolveRulesetDependencyAssembly(object? sender, ResolveEventArgs args)
|
|
{
|
|
var asm = new AssemblyName(args.Name);
|
|
|
|
// the requesting assembly may be located out of the executable's base directory, thus requiring manual resolving of its dependencies.
|
|
// this attempts resolving the ruleset dependencies on game core and framework assemblies by returning assemblies with the same assembly name
|
|
// already loaded in the AppDomain.
|
|
var domainAssembly = AppDomain.CurrentDomain.GetAssemblies()
|
|
// Given name is always going to be equally-or-more qualified than the assembly name.
|
|
.Where(a =>
|
|
{
|
|
string? name = a.GetName().Name;
|
|
if (name == null)
|
|
return false;
|
|
|
|
return args.Name.Contains(name, StringComparison.Ordinal);
|
|
})
|
|
// Pick the greatest assembly version.
|
|
.OrderByDescending(a => a.GetName().Version)
|
|
.FirstOrDefault();
|
|
|
|
if (domainAssembly != null)
|
|
return domainAssembly;
|
|
|
|
return LoadedAssemblies.Keys.FirstOrDefault(a => a.FullName == asm.FullName);
|
|
}
|
|
|
|
private void loadFromAppDomain()
|
|
{
|
|
foreach (var ruleset in AppDomain.CurrentDomain.GetAssemblies())
|
|
{
|
|
string? rulesetName = ruleset.GetName().Name;
|
|
|
|
if (rulesetName == null)
|
|
continue;
|
|
|
|
if (!rulesetName.StartsWith(ruleset_library_prefix, StringComparison.InvariantCultureIgnoreCase) || rulesetName.Contains(@"Tests"))
|
|
continue;
|
|
|
|
addRuleset(ruleset);
|
|
}
|
|
}
|
|
|
|
private void loadUserRulesets(Storage rulesetStorage)
|
|
{
|
|
var rulesets = rulesetStorage.GetFiles(@".", @$"{ruleset_library_prefix}.*.dll");
|
|
|
|
foreach (string? ruleset in rulesets.Where(f => !f.Contains(@"Tests")))
|
|
loadRulesetFromFile(rulesetStorage.GetFullPath(ruleset));
|
|
}
|
|
|
|
private void loadFromDisk()
|
|
{
|
|
try
|
|
{
|
|
string[] files = Directory.GetFiles(RuntimeInfo.StartupDirectory, @$"{ruleset_library_prefix}.*.dll");
|
|
|
|
foreach (string file in files.Where(f => !Path.GetFileName(f).Contains("Tests")))
|
|
loadRulesetFromFile(file);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logger.Error(e, $"Could not load rulesets from directory {RuntimeInfo.StartupDirectory}");
|
|
}
|
|
}
|
|
|
|
private void loadRulesetFromFile(string file)
|
|
{
|
|
string? filename = Path.GetFileNameWithoutExtension(file);
|
|
|
|
if (LoadedAssemblies.Values.Any(t => Path.GetFileNameWithoutExtension(t.Assembly.Location) == filename))
|
|
return;
|
|
|
|
try
|
|
{
|
|
addRuleset(Assembly.LoadFrom(file));
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logger.Error(e, $"Failed to load ruleset {filename}");
|
|
}
|
|
}
|
|
|
|
private void addRuleset(Assembly assembly)
|
|
{
|
|
if (LoadedAssemblies.ContainsKey(assembly))
|
|
return;
|
|
|
|
// the same assembly may be loaded twice in the same AppDomain (currently a thing in certain Rider versions https://youtrack.jetbrains.com/issue/RIDER-48799).
|
|
// as a failsafe, also compare by FullName.
|
|
if (LoadedAssemblies.Any(a => a.Key.FullName == assembly.FullName))
|
|
return;
|
|
|
|
try
|
|
{
|
|
LoadedAssemblies[assembly] = assembly.GetTypes().First(t => t.IsPublic && t.IsSubclassOf(typeof(Ruleset)));
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logger.Error(e, $"Failed to add ruleset {assembly}");
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
AppDomain.CurrentDomain.AssemblyResolve -= resolveRulesetDependencyAssembly;
|
|
}
|
|
|
|
#region Implementation of IRulesetStore
|
|
|
|
IRulesetInfo? IRulesetStore.GetRuleset(int id) => GetRuleset(id);
|
|
IRulesetInfo? IRulesetStore.GetRuleset(string shortName) => GetRuleset(shortName);
|
|
IEnumerable<IRulesetInfo> IRulesetStore.AvailableRulesets => AvailableRulesets;
|
|
|
|
#endregion
|
|
}
|
|
}
|