tweak patcher loader, configuration, and load context to load patcher from new folder structure

Author: Lordfirespeed

NetcodePatcher.Tools.Common/PatcherConfiguration.cs

@@ -3,21 +3,37 @@
 
 namespace NetcodePatcher.Tools.Common;
 
-public record PatcherConfiguration()
+public record PatcherConfiguration
 {
     public required Version UnityVersion { get; init; }
     public required Version NetcodeVersion { get; init; }
     public required Version TransportVersion { get; init; }
     public required bool NativeCollectionSupport { get; init; }
 
-    public string PatcherAssemblyFileName => Path.Combine(
-        $"uv{UnityVersion.Major}.{UnityVersion.Minor}",
-        $"tv{TransportVersion}",
-        $"NetcodePatcher.uv{UnityVersion.Major}.{UnityVersion.Minor}.nv{NetcodeVersion}.tv{TransportVersion}.{(NativeCollectionSupport ? "withNativeCollectionSupport" : "withoutNativeCollectionSupport")}.dll"
+    private readonly Lazy<string> _executingDir = new(
+        () => Path.GetFullPath(Path.GetDirectoryName(typeof(PatcherConfiguration).Assembly.Location)!)
+    );
+    public string ExecutingDir => _executingDir.Value;
+
+    public string PatcherCommonAssemblyDir => Path.Combine(
+        ExecutingDir,
+        $"unity-v{UnityVersion.Major}.{UnityVersion.Minor}",
+        $"unity-transport-v{TransportVersion}"
+    );
+
+    public string PatcherNetcodeSpecificAssemblyDir => Path.Combine(
+        PatcherCommonAssemblyDir,
+        $"netcode-v{NetcodeVersion}",
+        NativeCollectionSupport ? "with-native-collection-support" : "without-native-collection-support"
+    );
+
+    public string PatcherAssemblyFile => Path.Combine(
+        PatcherNetcodeSpecificAssemblyDir,
+        "NetcodePatcher.dll"
     );
 
     public override string ToString()
     {
         return $"PatcherConfiguration {{\nUnity {UnityVersion},\nNetcode {NetcodeVersion},\nTransport {TransportVersion},\nNative collection support? {NativeCollectionSupport}\n}}";
     }
-};
+}

NetcodePatcher.Tools.Common/PatcherLoadContext.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -8,12 +9,13 @@ namespace NetcodePatcher.Tools.Common;
 
 class PatcherLoadContext : AssemblyLoadContext
 {
+    private static readonly HashSet<string> SpecificAssemblyNames = [ "NetcodePatcher", "Unity.Netcode.Runtime" ];
     private static readonly HashSet<string> SharedDependencyAssemblyNames = [ "Serilog" ];
-    private readonly AssemblyDependencyResolver _resolver;
+    private readonly PatcherConfiguration _configuration;
 
-    public PatcherLoadContext(string name, string pluginPath) : base(name)
+    public PatcherLoadContext(string name, PatcherConfiguration configuration) : base(name)
     {
-        _resolver = new AssemblyDependencyResolver(pluginPath);
+        _configuration = configuration;
     }
 
     protected override Assembly? Load(AssemblyName assemblyName)
@@ -22,13 +24,49 @@ public PatcherLoadContext(string name, string pluginPath) : base(name)
             .FirstOrDefault(assembly => assembly.GetName() == assemblyName);
         if (loadedAssembly is not null) return loadedAssembly;
 
-        string? assemblyPath = _resolver.ResolveAssemblyToPath(assemblyName);
+        if (assemblyName.Name is null) return null;
+
+        if (SharedDependencyAssemblyNames.Contains(assemblyName.Name))
+            return Default.LoadFromAssemblyName(assemblyName);
+
+        string? assemblyPath = ResolveAssemblyToPath(assemblyName);
         if (assemblyPath is null) return null;
+        return LoadFromAssemblyPath(assemblyPath);
+    }
 
-        if (SharedDependencyAssemblyNames.Contains(Path.GetFileNameWithoutExtension(assemblyPath))) {
-            return Default.LoadFromAssemblyPath(assemblyPath);
+    private string? ResolveAssemblyToPath(AssemblyName assemblyName)
+    {
+        if (assemblyName.Name is null) return null;
+
+        if (SpecificAssemblyNames.Contains(assemblyName.Name))
+        {
+            if (TryResolveSpecificAssemblyToPath(assemblyName, out var specificPath))
+                return specificPath;
         }
 
-        return LoadFromAssemblyPath(assemblyPath);
+        if (TryResolveCommonAssemblyToPath(assemblyName, out var commonPath))
+            return commonPath;
+
+        return null;
+
+        bool TryResolveCommonAssemblyToPath(AssemblyName assemblyName, [MaybeNullWhen(false)] out string path)
+        {
+            path = Path.Combine(_configuration.PatcherCommonAssemblyDir, $"{assemblyName.Name}.dll");
+            if (File.Exists(path))
+                return true;
+
+            path = null;
+            return false;
+        }
+
+        bool TryResolveSpecificAssemblyToPath(AssemblyName assemblyName, [MaybeNullWhen(false)] out string path)
+        {
+            path = Path.Combine(_configuration.PatcherNetcodeSpecificAssemblyDir, $"{assemblyName.Name}.dll");
+            if (File.Exists(path))
+                return true;
+
+            path = null;
+            return false;
+        }
     }
 }

NetcodePatcher.Tools.Common/PatcherLoader.cs

@@ -7,6 +7,9 @@ namespace NetcodePatcher.Tools.Common;
 
 public class PatcherLoader
 {
+    private const string NetcodePatcherAssemblyNameString = "NetcodePatcher";
+    private static readonly AssemblyName NetcodePatcherAssemblyName = new(NetcodePatcherAssemblyNameString);
+
     private Type? _patcher;
 
     public Type Patcher => _patcher ??= LoadPatcher();
@@ -33,9 +36,14 @@ private Type LoadPatcher() => LoadPatcherAssembly(_configuration)
 
     private static Assembly LoadPatcherAssembly(PatcherConfiguration configuration)
     {
-        try {
+        try
+        {
             return LoadPatcherAssemblyUnsafe(configuration);
         }
+        catch (ArgumentException)
+        {
+            throw;
+        }
         catch (FileNotFoundException exc) {
             throw new ArgumentException($"The supplied patch configuration is either unknown or unsupported.\n{configuration}", exc);
         }
@@ -46,15 +54,12 @@ private static Assembly LoadPatcherAssembly(PatcherConfiguration configuration)
 
     private static Assembly LoadPatcherAssemblyUnsafe(PatcherConfiguration configuration)
     {
-        var executingAssemblyDir = Path.GetDirectoryName(typeof(PatcherLoader).Assembly.Location)!;
-        var patcherLocation = Path.GetFullPath(Path.Combine(executingAssemblyDir, configuration.PatcherAssemblyFileName));
-        Log.Debug("Loading patcher from {PatcherLocation}", patcherLocation);
-        PatcherLoadContext patcherLoadContext = new PatcherLoadContext("PatcherLoadContext", patcherLocation);
-        var patcherAssemblyName = new AssemblyName(Path.GetFileNameWithoutExtension(patcherLocation));
+        Log.Debug("Loading patcher from {PatcherLocation}",  configuration.PatcherAssemblyFile);
+        PatcherLoadContext patcherLoadContext = new PatcherLoadContext("PatcherLoadContext", configuration);
 
         Assembly patcherAssembly;
         try {
-            patcherAssembly = patcherLoadContext.LoadFromAssemblyName(patcherAssemblyName);
+            patcherAssembly = patcherLoadContext.LoadFromAssemblyName(NetcodePatcherAssemblyName);
         }
         catch (FileNotFoundException exc) {
             throw new ArgumentException($"The supplied patch configuration is either unknown or unsupported.\n{configuration}", exc);