Solve the dependency resolving between mods

FEZ.HAT.mm.csproj

@@ -10,7 +10,7 @@
     <RootNamespace>HatModLoader</RootNamespace>
 
     <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
+    <Nullable>disable</Nullable>
 
     <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
 

Installers/ModMenuInstaller.cs

@@ -105,10 +105,10 @@ private static void CreateAndAddModLevel(object MenuBase)
             else
             {
                 AddInactiveStringItem(null, null);
-                AddInactiveStringItem(null, () => Hat.Instance.Mods[modMenuCurrentIndex].Info.Name);
-                AddInactiveStringItem(null, () => Hat.Instance.Mods[modMenuCurrentIndex].Info.Description);
-                AddInactiveStringItem(null, () => $"made by {Hat.Instance.Mods[modMenuCurrentIndex].Info.Author}");
-                AddInactiveStringItem(null, () => $"version {Hat.Instance.Mods[modMenuCurrentIndex].Info.Version}");
+                AddInactiveStringItem(null, () => Hat.Instance.Mods[modMenuCurrentIndex].Metadata.Name);
+                AddInactiveStringItem(null, () => Hat.Instance.Mods[modMenuCurrentIndex].Metadata.Description);
+                AddInactiveStringItem(null, () => $"made by {Hat.Instance.Mods[modMenuCurrentIndex].Metadata.Author}");
+                AddInactiveStringItem(null, () => $"version {Hat.Instance.Mods[modMenuCurrentIndex].Metadata.Version}");
             }
 
             // add created menu level to the main menu

Patches/Fez.cs

@@ -31,7 +31,7 @@ public void ctor()
         protected override void Initialize()
         {
             HatML = new Hat(this);
-            HatML.InitalizeAssemblies();
+            HatML.InitializeAssemblies();
             //HatML.InitializeAssets(musicPass: false);
             orig_Initialize();
             DrawingTools.Init();
@@ -44,7 +44,7 @@ internal static void LoadComponents(Fez game)
             bool doLoad = !ServiceHelper.FirstLoadDone;
             orig_LoadComponents(game);
             if (doLoad) {
-                HatML.InitalizeComponents();
+                HatML.InitializeComponents();
             }
         }
 

Patches/FezLogo.cs

@@ -146,15 +146,15 @@ public override void Draw(GameTime gameTime)
             Viewport viewport = DrawingTools.GetViewport();
 
             int modCount = Hat.Instance.Mods.Count;
-            string hatText = $"HAT Mod Loader, version {Hat.Version}, {modCount} mod{(modCount != 1 ? "s" : "")} installed";
+            string hatText = $"HAT Mod Loader, version {Hat.VersionString}, {modCount} mod{(modCount != 1 ? "s" : "")} installed";
             if (modCount == 69) hatText += "... nice";
 
             Color textColor = Color.Lerp(Color.White, Color.Black, alpha);
             Color warningColor = Color.Lerp(Color.White, Color.Red, alpha);
 
             float lineHeight = DrawingTools.DefaultFont.LineSpacing * DrawingTools.DefaultFontSize;
 
-            int invalidModCount = Hat.Instance.InvalidMods.Count;
+            int invalidModCount = Hat.Instance.InvalidModsCount;
             string invalidModsText = $"Could not load {invalidModCount} mod{(invalidModCount != 1 ? "s" : "")}. Check logs for more details.";
 
             DrawingTools.BeginBatch();

Patches/Program.cs

@@ -1,7 +1,6 @@
 using Common;
 using HatModLoader.Source;
 using System.Globalization;
-using System.Runtime.InteropServices;
 
 namespace FezGame
 {
@@ -11,8 +10,8 @@ internal static class patch_Program
 
         private static void Main(string[] args)
         {
-            // Ensuring that dependency resolver is registered as soon as it's possible.
-            DependencyResolver.Register();
+            // Ensuring that required dependencies can be resolved before anything else.
+            Hat.RegisterRequiredDependencyResolvers();
 
             // Ensure uniform culture
             Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-GB");

Source/AssemblyResolving/AssemblyResolveCompability.cs

@@ -0,0 +1,56 @@
+using System.Reflection;
+
+namespace HatModLoader.Source.AssemblyResolving
+{
+    internal static class AssemblyResolveCompability
+    {
+        public static bool MatchesRequest(this AssemblyName assemblyName, ResolveEventArgs args, bool allowRollForward)
+        {
+            var requestedName = new AssemblyName(args.Name);
+
+            return assemblyName.Name == requestedName.Name &&
+                   assemblyName.CultureName == requestedName.CultureName &&
+                   ComparePublicKeyTokens(assemblyName.GetPublicKeyToken(), requestedName.GetPublicKeyToken()) &&
+                   CompareVersions(assemblyName.Version, requestedName.Version, allowRollForward);
+        }
+
+        private static bool ComparePublicKeyTokens(byte[] tokenA, byte[] tokenB)
+        {
+            // Avoiding usage of stuff like SequenceEqual to prevent accidental dependency request at this stage.
+
+            if (tokenA == null && tokenB == null)
+            {
+                return true;
+            }
+
+            if (tokenA == null || tokenB == null || tokenA.Length != tokenB.Length)
+            {
+                return false;
+            }
+
+            for (int i = 0; i < tokenA.Length; i++)
+            {
+                if (tokenA[i] != tokenB[i])
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool CompareVersions(Version checkedVersion, Version requiredVersion, bool allowRollForward)
+        {
+            if (allowRollForward)
+            {
+                return checkedVersion >= requiredVersion;
+            }
+
+            return checkedVersion.Major == requiredVersion.Major &&
+                   checkedVersion.Minor == requiredVersion.Minor &&
+                   checkedVersion.Build == requiredVersion.Build &&
+                   checkedVersion.Revision >= requiredVersion.Revision;
+        }
+    }
+}
+

Source/AssemblyResolving/AssemblyResolverRegistry.cs

@@ -0,0 +1,30 @@
+namespace HatModLoader.Source.AssemblyResolving
+{
+    internal static class AssemblyResolverRegistry
+    {
+        private static readonly HashSet<IAssemblyResolver> RegisteredResolvers = new();
+
+        public static void Register(IAssemblyResolver resolver)
+        {
+            if (RegisteredResolvers.Contains(resolver))
+            {
+                return;
+            }
+
+            RegisteredResolvers.Add(resolver);
+            AppDomain.CurrentDomain.AssemblyResolve += resolver.ProvideAssembly;
+        }
+
+        public static void Unregister(IAssemblyResolver resolver)
+        {
+            if (!RegisteredResolvers.Contains(resolver))
+            {
+                return;
+            }
+
+            RegisteredResolvers.Remove(resolver);
+            AppDomain.CurrentDomain.AssemblyResolve -= resolver.ProvideAssembly;
+        }
+    }
+}
+

Source/AssemblyResolving/HatSubdirectoryAssemblyResolver.cs

@@ -0,0 +1,69 @@
+using System.Reflection;
+
+namespace HatModLoader.Source.AssemblyResolving
+{
+    internal class HatSubdirectoryAssemblyResolver : IAssemblyResolver
+    {
+        private static readonly string DependencyDirectory = "HATDependencies";
+
+        private readonly string _subdirectoryName;
+
+        public HatSubdirectoryAssemblyResolver(string subdirectoryName)
+        {
+            this._subdirectoryName = subdirectoryName;
+        }
+
+
+        public Assembly ProvideAssembly(object sender, ResolveEventArgs args)
+        {
+            foreach (var file in EnumerateAssemblyFilesInSubdirectory())
+            {
+                if (!TryGetAssemblyName(file, out var assemblyName))
+                {
+                    continue;
+                }
+
+                if (assemblyName.MatchesRequest(args, true))
+                {
+                    return Assembly.LoadFrom(file);
+                }
+            }
+
+            return null;
+        }
+
+        private IEnumerable<string> EnumerateAssemblyFilesInSubdirectory()
+        {
+            var path = Path.Combine(DependencyDirectory, _subdirectoryName);
+
+            if (!Directory.Exists(path))
+            {
+                yield break;
+            }
+
+            foreach (var file in Directory.EnumerateFiles(path, "*.dll", SearchOption.TopDirectoryOnly))
+            {
+                yield return file;
+            }
+
+            foreach (var file in Directory.EnumerateFiles(path, "*.exe", SearchOption.TopDirectoryOnly))
+            {
+                yield return file;
+            }
+        }
+
+        private bool TryGetAssemblyName(string filePath, out AssemblyName assemblyName)
+        {
+            assemblyName = null;
+            try
+            {
+                assemblyName = AssemblyName.GetAssemblyName(filePath);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+    }
+}

Source/AssemblyResolving/IAssemblyResolver.cs

@@ -0,0 +1,10 @@
+using System.Reflection;
+
+namespace HatModLoader.Source.AssemblyResolving
+{
+    internal interface IAssemblyResolver
+    {
+        public Assembly ProvideAssembly(object sender, ResolveEventArgs args);
+    }
+}
+

Source/AssemblyResolving/ModInternalAssemblyResolver.cs

@@ -0,0 +1,68 @@
+using System.Reflection;
+using HatModLoader.Source.ModDefinition;
+using Mono.Cecil;
+
+namespace HatModLoader.Source.AssemblyResolving
+{
+    internal class ModInternalAssemblyResolver : IAssemblyResolver
+    {
+        private readonly ModIdentity _mod;
+
+        private readonly Dictionary<AssemblyName, string> _cachedAssemblyPaths = new();
+
+        public ModInternalAssemblyResolver(ModIdentity mod)
+        {
+            _mod = mod;
+            CacheAssemblyPaths();
+        }
+
+        public Assembly ProvideAssembly(object sender, ResolveEventArgs args)
+        {
+            if (_mod.CodeMod != null && _mod.CodeMod.Assembly.GetName().MatchesRequest(args, false))
+            {
+                return _mod.CodeMod.Assembly;
+            }
+
+            foreach(var assemblyName in _cachedAssemblyPaths.Keys)
+            {
+                if (assemblyName.MatchesRequest(args, false))
+                {
+                    using var assemblyData = _mod.FileProxy.OpenFile(_cachedAssemblyPaths[assemblyName]);
+                    var assemblyBytes = new byte[assemblyData.Length];
+                    assemblyData.Read(assemblyBytes, 0, assemblyBytes.Length);
+                    return Assembly.Load(assemblyBytes);
+                }
+            }
+            return null;
+        }
+
+        private void CacheAssemblyPaths()
+        {
+            foreach (var filePath in EnumerateAssemblyFilesInMod())
+            {
+                using var assemblyFile = _mod.FileProxy.OpenFile(filePath);
+                using var assemblyDef = AssemblyDefinition.ReadAssembly(assemblyFile, new ReaderParameters { ReadSymbols = false });
+                var fullName = new AssemblyName(assemblyDef.Name.ToString());
+
+                if (!_cachedAssemblyPaths.ContainsKey(fullName))
+                {
+                    _cachedAssemblyPaths[fullName] = filePath;
+                }
+            }
+        }
+
+        private IEnumerable<string> EnumerateAssemblyFilesInMod()
+        {
+            foreach (var file in _mod.FileProxy.EnumerateFiles(""))
+            {
+                if (
+                    file.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) || 
+                    file.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)
+                ) {
+                    yield return file;
+                }
+            }
+        }
+    }
+}
+