public void RunMonoMod()
{
Environment.SetEnvironmentVariable("MONOMOD_DEPENDENCY_MISSING_THROW", "0");
if (this.verbosity > 0)
{
Environment.SetEnvironmentVariable("MONOMOD_LOG_VERBOSE", "1");
}
using (MonoModder mm = new MonoModder()
{
InputPath = this.assemblyPath,
OutputPath = AssemblyTmpPath,
})
{
// read assembly
mm.Read();
// read Seshat.dll
mm.ReadMod(this.seshatPath);
mm.MapDependencies();
// autopatch
mm.AutoPatch();
// write assembly
mm.Write();
}
}
/// <summary>
/// Perform the actual patching of Assembly-CSharp.dll in the Risk of Rain 2 managed folder
/// </summary>
/// <param name="modPath">The path to the Assembly-CSharp.HexiDave.mm.dll file</param>
private static void PatchWithMod(string modPath)
{
// Ensure that we have an Assembly-CSharp.dll.original file to work from
FileUtilities.EnsureBackup();
// Get a temporary file to write the new assembly to
var outputPath = Path.GetTempFileName();
// Setup MonoModder to patch the original Assembly-CSharp.dll
using (var monoModder = new MonoModder
{
InputPath = FileUtilities.BackupAssemblyPath,
OutputPath = outputPath
})
{
// Read the assembly
monoModder.Read();
// Read the patch
monoModder.ReadMod(modPath);
// Ensure all the assembly references are still set
monoModder.MapDependencies();
// Re-write assembly with patch functions
monoModder.AutoPatch();
// Spit the file out
monoModder.Write();
}
// Clear the assembly in RoR2's managed folder
File.Delete(FileUtilities.AssemblyPath);
// Move the patched assembly into place
File.Move(outputPath, FileUtilities.AssemblyPath);
// Make sure any dependencies are moved
// TODO: Maybe remove this, but still tinkering
var filesToInclude = new[]
{
"Mono.Cecil.dll"
};
foreach (var fileName in filesToInclude)
{
var moveToPath = $@"{FileUtilities.ManagedPath}\{fileName}";
if (!File.Exists(moveToPath))
{
File.Move(fileName, moveToPath);
}
}
}
/// <summary>
/// Patches an assembly located in Managed.
/// </summary>
/// <param name="pathToPatch"></param>
/// <param name="assemblyName"></param>
public void PatchAssembly(string pathToPatch, string assemblyName, string[] dependencies)
{
string assemblyPath = FindAssemblyByName(assemblyName);
if (assemblyPath == string.Empty)
{
return;
}
string outputPath = Path.Combine(Directory.GetParent(assemblyPath).FullName, Path.GetFileNameWithoutExtension(assemblyPath) + "-NEW.dll");
Console.WriteLine(assemblyPath);
Console.WriteLine(outputPath);
using (MonoModder mm = new MonoModder()
{
InputPath = assemblyPath,
OutputPath = outputPath
}) {
mm.LogVerboseEnabled = true;
mm.Read();
//Force everything to be public
mm.PublicEverything = true;
//Read in the patch
mm.ReadMod(pathToPatch);
mm.MapDependencies();
mm.DependencyDirs.Add(Directory.GetParent(Assembly.GetExecutingAssembly().FullName).FullName);
mm.AutoPatch();
mm.Write();
}
File.Delete(assemblyPath);
File.Copy(outputPath, assemblyPath);
File.Delete(outputPath);
string managedPath = Directory.GetParent(assemblyPath).FullName;
foreach (string s in dependencies)
{
string dependencyDestination = Path.Combine(managedPath, Path.GetFileName(s));
if (File.Exists(dependencyDestination))
{
File.Delete(dependencyDestination);
}
File.Copy(s, dependencyDestination);
}
}
private void _Relink(string input, string output)
{
using (var modder = new MonoModder()
{
InputPath = input,
OutputPath = output
}) {
modder.CleanupEnabled = false;
modder.RelinkModuleMap = AssemblyRelinkMap;
modder.ReaderParameters.ReadSymbols = false;
modder.WriterParameters.WriteSymbols = false;
modder.WriterParameters.SymbolWriterProvider = null;
modder.Read();
modder.MapDependencies();
modder.AutoPatch();
modder.Write();
}
}
public void Patch()
{
// Load the assembly to check if it needs to be patched first
string assemblyPath = Path.Combine(_assemblyDirectory, AssemblyName);
string assemblyBackupPath = assemblyPath.Replace(AssemblyName, AssemblyBackupName);
if (!IsPatchingNeeded(assemblyPath))
{
Console.WriteLine("Game is already patched, no further action required.");
return;
}
// Copy the required assemblies to the game directory
foreach (var assemblyName in PatchAssemblies)
{
File.Copy(assemblyName, Path.Combine(_assemblyDirectory, assemblyName), true);
}
File.Copy(assemblyPath, assemblyBackupPath, true);
// Run MonoMod
Console.WriteLine("Patching game...");
using (MonoModder mm = new MonoModder()
{
InputPath = assemblyBackupPath,
OutputPath = assemblyPath + ".tmp"
})
{
Environment.SetEnvironmentVariable("MONOMOD_DEPENDENCY_MISSING_THROW", "0");
mm.Read();
mm.ReadMod(Path.Combine(_assemblyDirectory, AssemblyPatchName));
mm.MapDependencies();
mm.AutoPatch();
mm.Write();
}
// Copy the resultant assembly
File.Delete(assemblyPath);
File.Move(assemblyPath + ".tmp", assemblyPath);
}
public static void Main(string[] args)
{
// Backup the assembly before setup
FileUtilities.EnsureBackup();
// Rebuild the GamePath.targets file with correct game path
ReplaceGamePathTarget();
// Directory for storing 'public'-ified assembly
var libsDir = $@"{EnvHelper.SolutionDir}\libs";
// Ensure the path exists for output
Directory.CreateDirectory(libsDir);
// Output path for the assembly
var publicAssemblyPath = $@"{libsDir}\{FileUtilities.AssemblyFileName}";
// Remove the old one, if it exists
if (File.Exists(publicAssemblyPath))
{
File.Delete(publicAssemblyPath);
}
// Create the all-public assembly for import
using (var monoMod = new MonoModder
{
InputPath = FileUtilities.BackupAssemblyPath,
OutputPath = publicAssemblyPath
})
{
monoMod.Read();
monoMod.PublicEverything = true;
monoMod.MapDependencies();
monoMod.AutoPatch();
monoMod.Write();
}
}
public static Assembly GetRelinkedAssembly(this GameModMetadata meta, Stream stream, MissingDependencyResolver depResolver = null)
{
string name = Path.GetFileName(meta.DLL);
string cachedName = meta.Name + "." + name.Substring(0, name.Length - 3) + "dll";
string cachedPath = Path.Combine(ModLoader.ModsCacheDirectory, cachedName);
string cachedChecksumPath = Path.Combine(ModLoader.ModsCacheDirectory, cachedName + ".sum");
string[] checksums = new string[2];
using (MD5 md5 = MD5.Create()) {
if (GameChecksum == null)
{
using (FileStream fs = File.OpenRead(Assembly.GetAssembly(typeof(ModRelinker)).Location))
GameChecksum = md5.ComputeHash(fs).ToHexadecimalString();
}
checksums[0] = GameChecksum;
string modPath = meta.Archive;
if (modPath.Length == 0)
{
modPath = meta.DLL;
}
using (FileStream fs = File.OpenRead(modPath))
checksums[1] = md5.ComputeHash(fs).ToHexadecimalString();
}
if (File.Exists(cachedPath) && File.Exists(cachedChecksumPath) &&
checksums.ChecksumsEqual(File.ReadAllLines(cachedChecksumPath)))
{
return(Assembly.LoadFrom(cachedPath));
}
if (depResolver == null)
{
depResolver = _GenerateModDependencyResolver(meta);
}
using (MonoModder modder = new MonoModder()
{
Input = stream,
OutputPath = cachedPath,
CleanupEnabled = false,
RelinkModuleMap = AssemblyRelinkMap,
DependencyDirs =
{
ManagedDirectory
},
MissingDependencyResolver = depResolver,
RelinkMap = ModRuntimePatcher.Detourer.RelinkMap
})
try {
modder.ReaderParameters.ReadSymbols = false;
modder.WriterParameters.WriteSymbols = false;
modder.WriterParameters.SymbolWriterProvider = null;
modder.Read();
modder.MapDependencies();
modder.AutoPatch();
modder.Write();
} catch (Exception e) {
ModLogger.Log("relinker", $"Failed relinking {meta}: {e}");
return(null);
}
return(Assembly.LoadFrom(cachedPath));
}
/// <summary>
/// Relink a .dll to point towards the game's assembly at runtime, then load it.
/// </summary>
/// <param name="meta">The mod metadata, used for caching, among other things.</param>
/// <param name="stream">The stream to read the .dll from.</param>
/// <param name="depResolver">An optional dependency resolver.</param>
/// <param name="checksumsExtra">Any optional checksums. If you're running this at runtime, pass at least Relinker.GetChecksum(Metadata)</param>
/// <param name="prePatch">An optional step executed before patching, but after MonoMod has loaded the input assembly.</param>
/// <returns>The loaded, relinked assembly.</returns>
public static Assembly GetRelinkedAssembly(ModMetadata meta, Stream stream,
MissingDependencyResolver depResolver = null, string[] checksumsExtra = null, Action <MonoModder> prePatch = null)
{
string cachedPath = GetCachedPath(meta);
string cachedChecksumPath = cachedPath.Substring(0, cachedPath.Length - 4) + ".sum";
string[] checksums = new string[2 + (checksumsExtra?.Length ?? 0)];
if (GameChecksum == null)
{
GameChecksum = GetChecksum(Assembly.GetAssembly(typeof(Utils.Relinker)).Location);
}
checksums[0] = GameChecksum;
checksums[1] = GetChecksum(meta);
if (checksumsExtra != null)
{
for (int i = 0; i < checksumsExtra.Length; i++)
{
checksums[i + 2] = checksumsExtra[i];
}
}
if (File.Exists(cachedPath) && File.Exists(cachedChecksumPath) &&
ChecksumsEqual(checksums, File.ReadAllLines(cachedChecksumPath)))
{
Logger.Log(LogLevel.Verbose, "relinker", $"Loading cached assembly for {meta}");
try {
return(Assembly.LoadFrom(cachedPath));
} catch (Exception e) {
Logger.Log(LogLevel.Warn, "relinker", $"Failed loading {meta}");
e.LogDetailed();
return(null);
}
}
if (depResolver == null)
{
depResolver = GenerateModDependencyResolver(meta);
}
try {
MonoModder modder = Modder;
modder.Input = stream;
modder.OutputPath = cachedPath;
modder.MissingDependencyResolver = depResolver;
string symbolPath;
modder.ReaderParameters.SymbolStream = meta.OpenStream(out symbolPath, meta.DLL.Substring(0, meta.DLL.Length - 4) + ".pdb", meta.DLL + ".mdb");
modder.ReaderParameters.ReadSymbols = modder.ReaderParameters.SymbolStream != null;
if (modder.ReaderParameters.SymbolReaderProvider != null &&
modder.ReaderParameters.SymbolReaderProvider is RelinkerSymbolReaderProvider)
{
((RelinkerSymbolReaderProvider)modder.ReaderParameters.SymbolReaderProvider).Format =
string.IsNullOrEmpty(symbolPath) ? DebugSymbolFormat.Auto :
symbolPath.EndsWith(".mdb") ? DebugSymbolFormat.MDB :
symbolPath.EndsWith(".pdb") ? DebugSymbolFormat.PDB :
DebugSymbolFormat.Auto;
}
modder.Read();
modder.ReaderParameters.ReadSymbols = false;
if (modder.ReaderParameters.SymbolReaderProvider != null &&
modder.ReaderParameters.SymbolReaderProvider is RelinkerSymbolReaderProvider)
{
((RelinkerSymbolReaderProvider)modder.ReaderParameters.SymbolReaderProvider).Format = DebugSymbolFormat.Auto;
}
modder.MapDependencies();
if (RuntimeRuleContainer != null)
{
modder.ParseRules(RuntimeRuleContainer);
RuntimeRuleContainer = null;
}
prePatch?.Invoke(modder);
modder.AutoPatch();
modder.Write();
} catch (Exception e) {
Logger.Log(LogLevel.Warn, "relinker", $"Failed relinking {meta}");
e.LogDetailed();
return(null);
} finally {
Modder.ClearCaches(moduleSpecific: true);
Modder.Module.Dispose();
Modder.Module = null;
Modder.ReaderParameters.SymbolStream?.Dispose();
}
if (File.Exists(cachedChecksumPath))
{
File.Delete(cachedChecksumPath);
}
File.WriteAllLines(cachedChecksumPath, checksums);
Logger.Log(LogLevel.Verbose, "relinker", $"Loading assembly for {meta}");
try {
return(Assembly.LoadFrom(cachedPath));
} catch (Exception e) {
Logger.Log(LogLevel.Warn, "relinker", $"Failed loading {meta}");
e.LogDetailed();
return(null);
}
}
public static bool Mod(this InstallerWindow ins, string file)
{
string inPath = Path.Combine(ins.MainModDir, file);
string outPath = Path.Combine(ins.MainModDir, file + ".tmp.dll");
MonoModder monomod = new MonoModder()
{
InputPath = inPath,
OutputPath = outPath
};
monomod.SetupETGModder();
using (FileStream fileStream = File.Open(LogPath, FileMode.Append)) {
using (StreamWriter streamWriter = new StreamWriter(fileStream)) {
monomod.Logger = (string s) => ins.OnActivity();
monomod.Logger += (string s) => streamWriter.WriteLine(s);
// Unity wants .mdbs
// monomod.WriterParameters.SymbolWriterProvider = new Mono.Cecil.Mdb.MdbWriterProvider();
string db = Path.ChangeExtension(inPath, "pdb");
string dbTmp = Path.ChangeExtension(outPath, "pdb");
if (!File.Exists(db))
{
db = inPath + ".mdb";
dbTmp = outPath + ".mdb";
}
#if !DEBUG
RETRY:
try {
#endif
monomod.Read(); // Read main module first
monomod.ReadMod(Directory.GetParent(inPath).FullName); // ... then mods
monomod.MapDependencies(); // ... then all dependencies
monomod.AutoPatch(); // Patch,
monomod.Write(); // and write.
monomod.Dispose(); // Finally, dispose, because file access happens now.
File.Delete(inPath);
File.Move(outPath, inPath);
if (File.Exists(db))
{
File.Delete(db);
}
if (File.Exists(dbTmp))
{
File.Move(dbTmp, db);
}
return(true);
#if !DEBUG
} catch (ArgumentException e) {
monomod.Dispose();
if (File.Exists(db))
{
File.Delete(db);
if (File.Exists(dbTmp))
{
File.Delete(dbTmp);
}
goto RETRY;
}
ins.LogLine(e.ToString());
throw;
return(false);
} catch (Exception e) {
monomod.Dispose();
ins.LogLine(e.ToString());
throw;
return(false);
}
#endif
}
}
}
/// <summary>
/// Relink a .dll to point towards Celeste.exe and FNA / XNA properly at runtime, then load it.
/// </summary>
/// <param name="meta">The mod metadata, used for caching, among other things.</param>
/// <param name="stream">The stream to read the .dll from.</param>
/// <param name="depResolver">An optional dependency resolver.</param>
/// <param name="checksumsExtra">Any optional checksums. If you're running this at runtime, pass at least Everest.Relinker.GetChecksum(Metadata)</param>
/// <param name="prePatch">An optional step executed before patching, but after MonoMod has loaded the input assembly.</param>
/// <returns>The loaded, relinked assembly.</returns>
public static Assembly GetRelinkedAssembly(Stream stream, string modName)
{
string cachedPath = GetCachedPath(modName);
MissingDependencyResolver depResolver = GenerateModDependencyResolver();
try
{
MonoModder modder = Modder;
modder.Input = stream;
modder.OutputPath = cachedPath;
modder.MissingDependencyResolver = depResolver;
modder.ReaderParameters.ReadSymbols = false;
if (modder.ReaderParameters.SymbolReaderProvider is RelinkerSymbolReaderProvider)
{
((RelinkerSymbolReaderProvider)modder.ReaderParameters.SymbolReaderProvider).Format = DebugSymbolFormat.Auto;
}
modder.Read();
modder.ReaderParameters.ReadSymbols = false;
if (modder.ReaderParameters.SymbolReaderProvider != null &&
modder.ReaderParameters.SymbolReaderProvider is RelinkerSymbolReaderProvider)
{
((RelinkerSymbolReaderProvider)modder.ReaderParameters.SymbolReaderProvider).Format = DebugSymbolFormat.Auto;
}
modder.MapDependencies();
modder.AutoPatch();
modder.Write();
}
catch (Exception e)
{
Logger.LogError($"[API] Failed relinking\n{e}");
e.LogDetailed();
return(null);
}
finally
{
Modder.ClearCaches(moduleSpecific: true);
Modder.Module.Dispose();
Modder.Module = null;
Modder.ReaderParameters.SymbolStream?.Dispose();
}
Logger.LogDebug($"[API] Loading assembly for {modName}");
try
{
return(Assembly.LoadFrom(cachedPath));
}
catch (Exception e)
{
Logger.LogError($"[API] Failed loading\n{e}");
e.LogDetailed();
return(null);
}
}
public static void Main(string[] args)
{
#if CECIL0_9
throw new NotSupportedException();
#else
Console.WriteLine("MonoMod.DebugIL " + typeof(Program).Assembly.GetName().Version);
if (args.Length == 0)
{
Console.WriteLine("No valid arguments (assembly path) passed.");
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return;
}
string pathIn;
string pathOut;
int pathInI = 0;
for (int i = 0; i < args.Length; i++)
{
if (args[i] == "--relative")
{
Environment.SetEnvironmentVariable("MONOMOD_DEBUGIL_RELATIVE", "1");
pathInI = i + 1;
}
else if (args[i] == "--skip-maxstack")
{
Environment.SetEnvironmentVariable("MONOMOD_DEBUGIL_SKIP_MAXSTACK", "1");
pathInI = i + 1;
}
}
if (pathInI >= args.Length)
{
Console.WriteLine("No assembly path passed.");
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return;
}
pathIn = args[pathInI];
pathOut = args.Length != 1 && pathInI != args.Length - 1 ? args[args.Length - 1] : null;
pathOut = pathOut ?? Path.Combine(Path.GetDirectoryName(pathIn), "MMDBGIL_" + Path.GetFileName(pathIn));
using (MonoModder mm = new MonoModder()
{
InputPath = pathIn,
OutputPath = pathOut
}) {
mm.Read();
mm.Log("[DbgILGen] DebugILGenerator.Generate(mm);");
DebugILGenerator.Generate(mm);
mm.Write();
mm.Log("[DbgILGen] Done.");
}
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
#endif
}
public static void Main(string[] args)
{
Console.WriteLine("MonoMod " + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version);
if (args.Length == 0)
{
Console.WriteLine("No valid arguments (assembly path) passed.");
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return;
}
string pathIn;
string pathOut;
if (args.Length > 1 &&
args[0] == "--generate-debug-il" ||
args[0] == "--gen-dbg-il")
{
Console.WriteLine("[DbgILGen] Generating debug hierarchy and debug data (pdb / mdb).");
pathIn = args[1];
pathOut = args.Length != 2 ? args[args.Length - 1] : Path.Combine(Path.GetDirectoryName(pathIn), "MMDBGIL_" + Path.GetFileName(pathIn));
using (MonoModder mm = new MonoModder()
{
InputPath = pathIn,
OutputPath = pathOut
}) {
mm.Read(false);
mm.Log("[DbgILGen] DebugILGenerator.Generate(mm);");
DebugILGenerator.Generate(mm);
mm.Write();
mm.Log("[DbgILGen] Done.");
}
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return;
}
int pathInI = 0;
for (int i = 0; i < args.Length; i++)
{
if (args[i] == "--dependency-missing-throw=0" || args[i] == "--lean-dependencies")
{
Environment.SetEnvironmentVariable("MONOMOD_DEPENDENCY_MISSING_THROW", "0");
pathInI = i + 1;
}
else if (args[i] == "--cleanup=0" || args[i] == "--skip-cleanup")
{
Environment.SetEnvironmentVariable("MONOMOD_CLEANUP", "0");
pathInI = i + 1;
}
else if (args[i] == "--cleanup-all=1" || args[i] == "--cleanup-all")
{
Environment.SetEnvironmentVariable("MONOMOD_CLEANUP_ALL", "1");
pathInI = i + 1;
}
else if (args[i] == "--verbose=1" || args[i] == "--verbose" || args[i] == "-v")
{
Environment.SetEnvironmentVariable("MONOMOD_VERBOSE", "1");
pathInI = i + 1;
}
}
if (pathInI >= args.Length)
{
Console.WriteLine("No assembly path passed.");
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return;
}
pathIn = args[pathInI];
pathOut = args.Length != 1 && pathInI != args.Length - 1 ? args[args.Length - 1] : Path.Combine(Path.GetDirectoryName(pathIn), "MONOMODDED_" + Path.GetFileName(pathIn));
if (File.Exists(pathOut))
{
File.Delete(pathOut);
}
try {
using (MonoModder mm = new MonoModder()
{
InputPath = pathIn,
OutputPath = pathOut,
Verbose = Environment.GetEnvironmentVariable("MONOMOD_VERBOSE") == "1"
}) {
mm.Read(false);
if (args.Length <= 2)
{
mm.Log("[Main] Scanning for mods in directory.");
mm.ReadMod(Directory.GetParent(pathIn).FullName);
}
else
{
mm.Log("[Main] Reading mods list from arguments.");
for (int i = pathInI + 1; i < args.Length - 2; i++)
{
mm.ReadMod(args[i]);
}
}
mm.Read(true);
mm.Log("[Main] mm.AutoPatch();");
mm.AutoPatch();
mm.Write();
mm.Log("[Main] Done.");
}
} catch (Exception e) {
Console.WriteLine(e);
}
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
}
/// <summary>
/// Relink a .dll to point towards Celeste.exe and FNA / XNA properly at runtime, then load it.
/// </summary>
/// <param name="meta">The mod metadata, used for caching, among other things.</param>
/// <param name="stream">The stream to read the .dll from.</param>
/// <param name="depResolver">An optional dependency resolver.</param>
/// <param name="checksumsExtra">Any optional checksums</param>
/// <param name="prePatch">An optional step executed before patching, but after MonoMod has loaded the input assembly.</param>
/// <returns>The loaded, relinked assembly.</returns>
public static Assembly GetRelinkedAssembly(EverestModuleMetadata meta, string asmname, Stream stream,
MissingDependencyResolver depResolver = null, string[] checksumsExtra = null, Action <MonoModder> prePatch = null)
{
if (!Flags.SupportRelinkingMods)
{
Logger.Log(LogLevel.Warn, "relinker", "Relinker disabled!");
return(null);
}
string cachedPath = GetCachedPath(meta, asmname);
string cachedChecksumPath = cachedPath.Substring(0, cachedPath.Length - 4) + ".sum";
string[] checksums = new string[2 + (checksumsExtra?.Length ?? 0)];
if (GameChecksum == null)
{
GameChecksum = Everest.GetChecksum(Assembly.GetAssembly(typeof(Relinker)).Location).ToHexadecimalString();
}
checksums[0] = GameChecksum;
checksums[1] = Everest.GetChecksum(ref stream).ToHexadecimalString();
if (checksumsExtra != null)
{
for (int i = 0; i < checksumsExtra.Length; i++)
{
checksums[i + 2] = checksumsExtra[i];
}
}
if (File.Exists(cachedPath) && File.Exists(cachedChecksumPath) &&
ChecksumsEqual(checksums, File.ReadAllLines(cachedChecksumPath)))
{
Logger.Log(LogLevel.Verbose, "relinker", $"Loading cached assembly for {meta} - {asmname}");
try {
Assembly asm = Assembly.LoadFrom(cachedPath);
_RelinkedAssemblies.Add(asm);
return(asm);
} catch (Exception e) {
Logger.Log(LogLevel.Warn, "relinker", $"Failed loading {meta} - {asmname}");
e.LogDetailed();
return(null);
}
}
if (depResolver == null)
{
depResolver = GenerateModDependencyResolver(meta);
}
bool temporaryASM = false;
try {
MonoModder modder = Modder;
modder.Input = stream;
modder.OutputPath = cachedPath;
modder.MissingDependencyResolver = depResolver;
string symbolPath;
modder.ReaderParameters.SymbolStream = OpenStream(meta, out symbolPath, meta.DLL.Substring(0, meta.DLL.Length - 4) + ".pdb", meta.DLL + ".mdb");
modder.ReaderParameters.ReadSymbols = modder.ReaderParameters.SymbolStream != null;
if (modder.ReaderParameters.SymbolReaderProvider != null &&
modder.ReaderParameters.SymbolReaderProvider is RelinkerSymbolReaderProvider)
{
((RelinkerSymbolReaderProvider)modder.ReaderParameters.SymbolReaderProvider).Format =
string.IsNullOrEmpty(symbolPath) ? DebugSymbolFormat.Auto :
symbolPath.EndsWith(".mdb") ? DebugSymbolFormat.MDB :
symbolPath.EndsWith(".pdb") ? DebugSymbolFormat.PDB :
DebugSymbolFormat.Auto;
}
try {
modder.ReaderParameters.ReadSymbols = true;
modder.Read();
} catch {
modder.ReaderParameters.SymbolStream?.Dispose();
modder.ReaderParameters.SymbolStream = null;
modder.ReaderParameters.ReadSymbols = false;
stream.Seek(0, SeekOrigin.Begin);
modder.Read();
}
if (modder.ReaderParameters.SymbolReaderProvider != null &&
modder.ReaderParameters.SymbolReaderProvider is RelinkerSymbolReaderProvider)
{
((RelinkerSymbolReaderProvider)modder.ReaderParameters.SymbolReaderProvider).Format = DebugSymbolFormat.Auto;
}
modder.MapDependencies();
if (!RuntimeRulesParsed)
{
RuntimeRulesParsed = true;
InitMMSharedData();
string rulesPath = Path.Combine(
Path.GetDirectoryName(typeof(Celeste).Assembly.Location),
Path.GetFileNameWithoutExtension(typeof(Celeste).Assembly.Location) + ".Mod.mm.dll"
);
if (!File.Exists(rulesPath))
{
// Fallback if someone renamed Celeste.exe
rulesPath = Path.Combine(
Path.GetDirectoryName(typeof(Celeste).Assembly.Location),
"Celeste.Mod.mm.dll"
);
}
if (File.Exists(rulesPath))
{
ModuleDefinition rules = ModuleDefinition.ReadModule(rulesPath, new ReaderParameters(ReadingMode.Immediate));
modder.ParseRules(rules);
rules.Dispose(); // Is this safe?
}
}
prePatch?.Invoke(modder);
modder.ParseRules(modder.Module);
modder.AutoPatch();
RetryWrite:
try {
modder.WriterParameters.WriteSymbols = true;
modder.Write();
} catch {
try {
modder.WriterParameters.WriteSymbols = false;
modder.Write();
} catch when(!temporaryASM)
{
temporaryASM = true;
long stamp = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
cachedPath = Path.Combine(Path.GetTempPath(), $"Everest.Relinked.{Path.GetFileNameWithoutExtension(cachedPath)}.{stamp}.dll");
modder.Module.Name += "." + stamp;
modder.Module.Assembly.Name.Name += "." + stamp;
modder.OutputPath = cachedPath;
modder.WriterParameters.WriteSymbols = true;
goto RetryWrite;
}
}
} catch (Exception e) {
Logger.Log(LogLevel.Warn, "relinker", $"Failed relinking {meta} - {asmname}");
e.LogDetailed();
return(null);
} finally {
Modder.ReaderParameters.SymbolStream?.Dispose();
if (SharedModder)
{
Modder.ClearCaches(moduleSpecific: true);
Modder.Module.Dispose();
Modder.Module = null;
}
else
{
Modder.Dispose();
Modder = null;
}
}
if (File.Exists(cachedChecksumPath))
{
File.Delete(cachedChecksumPath);
}
if (!temporaryASM)
{
File.WriteAllLines(cachedChecksumPath, checksums);
}
Logger.Log(LogLevel.Verbose, "relinker", $"Loading assembly for {meta} - {asmname}");
try {
Assembly asm = Assembly.LoadFrom(cachedPath);
_RelinkedAssemblies.Add(asm);
return(asm);
} catch (Exception e) {
Logger.Log(LogLevel.Warn, "relinker", $"Failed loading {meta} - {asmname}");
e.LogDetailed();
return(null);
}
}
public static int Main(string[] args)
{
Console.WriteLine("MonoMod " + typeof(Program).GetTypeInfo().Assembly.GetName().Version);
if (args.Length == 0)
{
Console.WriteLine("No valid arguments (assembly path) passed.");
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return(0);
}
string pathIn;
string pathOut;
int pathInI = 0;
for (int i = 0; i < args.Length; i++)
{
if (args[i] == "--dependency-missing-throw=0" || args[i] == "--lean-dependencies")
{
Environment.SetEnvironmentVariable("MONOMOD_DEPENDENCY_MISSING_THROW", "0");
pathInI = i + 1;
}
else if (args[i] == "--cleanup=0" || args[i] == "--skip-cleanup")
{
Environment.SetEnvironmentVariable("MONOMOD_CLEANUP", "0");
pathInI = i + 1;
}
else if (args[i] == "--cleanup-all=1" || args[i] == "--cleanup-all")
{
Environment.SetEnvironmentVariable("MONOMOD_CLEANUP_ALL", "1");
pathInI = i + 1;
}
else if (args[i] == "--verbose=1" || args[i] == "--verbose" || args[i] == "-v")
{
Environment.SetEnvironmentVariable("MONOMOD_LOG_VERBOSE", "1");
pathInI = i + 1;
}
else if (args[i] == "--cache=0" || args[i] == "--uncached")
{
Environment.SetEnvironmentVariable("MONOMOD_RELINKER_CACHED", "0");
pathInI = i + 1;
}
}
if (pathInI >= args.Length)
{
Console.WriteLine("No assembly path passed.");
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return(0);
}
pathIn = args[pathInI];
pathOut = args.Length != 1 && pathInI != args.Length - 1 ? args[args.Length - 1] : null;
pathOut = pathOut ?? Path.Combine(Path.GetDirectoryName(pathIn), "MONOMODDED_" + Path.GetFileName(pathIn));
if (File.Exists(pathOut))
{
File.Delete(pathOut);
}
#if !DEBUG
try {
#endif
using (MonoModder mm = new MonoModder()
{
InputPath = pathIn,
OutputPath = pathOut
}) {
mm.Read();
if (args.Length <= 2)
{
mm.Log("[Main] Scanning for mods in directory.");
mm.ReadMod(Directory.GetParent(pathIn).FullName);
}
else
{
mm.Log("[Main] Reading mods list from arguments.");
for (int i = pathInI + 1; i < args.Length - 1; i++)
{
mm.ReadMod(args[i]);
}
}
mm.MapDependencies();
mm.Log("[Main] mm.AutoPatch();");
mm.AutoPatch();
mm.Write();
mm.Log("[Main] Done.");
}
#if !DEBUG
}
catch (Exception e) {
Console.WriteLine(e);
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return(-1);
}
#endif
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return(0);
}
public static int Main(string[] args)
{
Console.WriteLine("MonoMod " + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version);
if (args.Length == 0)
{
Console.WriteLine("No valid arguments (assembly path) passed.");
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return(0);
}
if (args[0] == "--test")
{
Console.WriteLine("[QuickDebugTest] Running...");
int result = QuickDebugTest.Run(args);
if (result == 0)
{
Console.WriteLine("[QuickDebugTest] Passed!");
}
else
{
Console.WriteLine($"[QuickDebugTest] Failed: {result}");
}
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return(result);
}
string pathIn;
string pathOut;
int pathInI = 0;
bool generateDebugIL = false;
for (int i = 0; i < args.Length; i++)
{
if (args[i] == "--dependency-missing-throw=0" || args[i] == "--lean-dependencies")
{
Environment.SetEnvironmentVariable("MONOMOD_DEPENDENCY_MISSING_THROW", "0");
pathInI = i + 1;
}
else if (args[i] == "--cleanup=0" || args[i] == "--skip-cleanup")
{
Environment.SetEnvironmentVariable("MONOMOD_CLEANUP", "0");
pathInI = i + 1;
}
else if (args[i] == "--cleanup-all=1" || args[i] == "--cleanup-all")
{
Environment.SetEnvironmentVariable("MONOMOD_CLEANUP_ALL", "1");
pathInI = i + 1;
}
else if (args[i] == "--verbose=1" || args[i] == "--verbose" || args[i] == "-v")
{
Environment.SetEnvironmentVariable("MONOMOD_LOG_VERBOSE", "1");
pathInI = i + 1;
}
else if (args[i] == "--cache=0" || args[i] == "--uncached")
{
Environment.SetEnvironmentVariable("MONOMOD_RELINKER_CACHED", "0");
pathInI = i + 1;
}
else if (args[i] == "--generate-debug-il" || args[i] == "--gen-dbg-il")
{
generateDebugIL = true;
pathInI = i + 1;
}
else if (args[i] == "--debug-il-relative" || args[i] == "--dbg-il-relative")
{
Environment.SetEnvironmentVariable("MONOMOD_DEBUGIL_RELATIVE", "1");
pathInI = i + 1;
}
}
if (pathInI >= args.Length)
{
Console.WriteLine("No assembly path passed.");
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return(0);
}
pathIn = args[pathInI];
pathOut = args.Length != 1 && pathInI != args.Length - 1 ? args[args.Length - 1] : null;
if (generateDebugIL)
{
Console.WriteLine("[DbgILGen] Generating debug hierarchy and debug data (pdb / mdb).");
pathOut = pathOut ?? Path.Combine(Path.GetDirectoryName(pathIn), "MMDBGIL_" + Path.GetFileName(pathIn));
using (MonoModder mm = new MonoModder()
{
InputPath = pathIn,
OutputPath = pathOut
}) {
mm.Read();
mm.Log("[DbgILGen] DebugILGenerator.Generate(mm);");
DebugILGenerator.Generate(mm);
mm.Write();
mm.Log("[DbgILGen] Done.");
}
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return(0);
}
pathOut = pathOut ?? Path.Combine(Path.GetDirectoryName(pathIn), "MONOMODDED_" + Path.GetFileName(pathIn));
if (File.Exists(pathOut))
{
File.Delete(pathOut);
}
#if !DEBUG
try {
#endif
using (MonoModder mm = new MonoModder()
{
InputPath = pathIn,
OutputPath = pathOut
}) {
mm.Read();
if (args.Length <= 2)
{
mm.Log("[Main] Scanning for mods in directory.");
mm.ReadMod(Directory.GetParent(pathIn).FullName);
}
else
{
mm.Log("[Main] Reading mods list from arguments.");
for (int i = pathInI + 1; i < args.Length - 1; i++)
{
mm.ReadMod(args[i]);
}
}
mm.MapDependencies();
mm.Log("[Main] mm.AutoPatch();");
mm.AutoPatch();
mm.Write();
mm.Log("[Main] Done.");
}
#if !DEBUG
}
catch (Exception e) {
Console.WriteLine(e);
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return(-1);
}
#endif
if (System.Diagnostics.Debugger.IsAttached) // Keep window open when running in IDE
{
Console.ReadKey();
}
return(0);
}
public static Assembly GetRelinkedAssembly(EverestModuleMetadata meta, Stream stream,
MissingDependencyResolver depResolver = null, string[] checksumsExtra = null, Action <MonoModder> prePatch = null)
{
string cachedPath = GetCachedPath(meta);
string cachedChecksumPath = cachedPath.Substring(0, cachedPath.Length - 4) + ".sum";
string[] checksums = new string[2 + (checksumsExtra?.Length ?? 0)];
if (GameChecksum == null)
{
GameChecksum = GetChecksum(Assembly.GetAssembly(typeof(Relinker)).Location);
}
checksums[0] = GameChecksum;
checksums[1] = GetChecksum(meta);
if (checksumsExtra != null)
{
for (int i = 0; i < checksumsExtra.Length; i++)
{
checksums[i + 2] = checksumsExtra[i];
}
}
if (File.Exists(cachedPath) && File.Exists(cachedChecksumPath) &&
ChecksumsEqual(checksums, File.ReadAllLines(cachedChecksumPath)))
{
return(Assembly.LoadFrom(cachedPath));
}
if (depResolver == null)
{
depResolver = GenerateModDependencyResolver(meta);
}
try {
MonoModder modder = Modder;
modder.Input = stream;
modder.OutputPath = cachedPath;
modder.MissingDependencyResolver = depResolver;
modder.Read();
modder.MapDependencies();
prePatch?.Invoke(modder);
modder.AutoPatch();
modder.Write();
} catch (Exception e) {
Logger.Log("relinker", $"Failed relinking {meta}: {e}");
return(null);
} finally {
Modder.ClearCaches(moduleSpecific: true);
Modder.Module.Dispose();
Modder.Module = null;
}
if (File.Exists(cachedChecksumPath))
{
File.Delete(cachedChecksumPath);
}
File.WriteAllLines(cachedChecksumPath, checksums);
return(Assembly.LoadFrom(cachedPath));
}
public void Install(Installer installer, bool leave_mmdlls = false)
{
var managed = installer.ManagedDir;
if (HasPluginsDir)
{
_InstallPlugins(installer.PluginsDir);
}
if (RequiresPatchedExe)
{
installer.PatchExe();
}
using (StreamWriter patches_info_writer = new StreamWriter(File.OpenWrite(installer.PatchesInfoFile))) {
patches_info_writer.WriteLine($"{Name} {VersionName}");
}
_Install("assembly", Assemblies, managed);
_Install("MonoMod patch DLL", PatchDLLs, managed);
_Install("file", OtherFiles, managed, subdir: true);
_Install("directory", Dirs, managed, subdir: true);
foreach (var patch_target in Metadata?.OrderedTargets ?? installer.Downloader.GungeonMetadata.ViablePatchTargets)
{
var patch_target_dll = Path.Combine(managed, $"{patch_target}.dll");
var patch_target_tmp = Path.Combine(managed, $"{patch_target}{TMP_PATCH_SUFFIX}");
var modder = new MonoModder {
InputPath = patch_target_dll,
OutputPath = patch_target_tmp
};
if (Metadata != null && Metadata.RelinkMap != null)
{
Dictionary <string, string> rmap;
if (Metadata.RelinkMap.TryGetValue(patch_target, out rmap))
{
_Logger.Info($"Reading component relink map for target {patch_target}");
foreach (var pair in rmap)
{
ModuleDefinition module;
if (!modder.DependencyCache.TryGetValue(pair.Value, out module))
{
var path = Path.Combine(managed, pair.Value);
_Logger.Debug($"Dependency not in cache: {pair.Value} ({path})");
module = modder.DependencyCache[pair.Value] = ModuleDefinition.ReadModule(path);
}
_Logger.Debug($"Mapping {pair.Key} => {pair.Value}");
modder.RelinkModuleMap[pair.Key] = module;
}
}
}
modder.Read();
var found_mods = false;
foreach (var dll in PatchDLLs)
{
if (File.Exists(Path.Combine(managed, dll)) && dll.StartsWith($"{patch_target}.", StringComparison.InvariantCulture))
{
found_mods = true;
_Logger.Debug($"Using patch DLL: {dll}");
modder.ReadMod(Path.Combine(managed, dll));
}
}
if (!found_mods)
{
_Logger.Info($"Not patching {patch_target} because this component has no patches for it");
continue;
}
_Logger.Info($"Patching target: {patch_target}");
modder.MapDependencies();
modder.AutoPatch();
modder.Write();
modder.Dispose();
_Logger.Debug($"Replacing original ({patch_target_tmp} => {patch_target_dll})");
if (File.Exists(patch_target_dll))
{
File.Delete(patch_target_dll);
}
File.Move(patch_target_tmp, patch_target_dll);
}
if (!leave_mmdlls)
{
foreach (var dll in PatchDLLs)
{
if (!File.Exists(Path.Combine(managed, dll)))
{
continue;
}
_Logger.Debug($"Cleaning up patch DLL {dll}");
File.Delete(Path.Combine(managed, dll));
}
}
_Logger.Debug($"Cleaning up patched DLL MDB/PDBs");
foreach (var ent in Directory.GetFileSystemEntries(managed))
{
if (ent.EndsWith($"{TMP_PATCH_SUFFIX}.mdb", StringComparison.InvariantCulture))
{
File.Delete(ent);
}
}
}
public static Type ExecuteRules(this MonoModder self, TypeDefinition orig)
{
ModuleDefinition wrapper = ModuleDefinition.CreateModule(
$"{orig.Module.Name.Substring(0, orig.Module.Name.Length - 4)}.MonoModRules -ID:{MMILProxyManager.GetId(self)} -MMILRT",
new ModuleParameters()
{
Architecture = orig.Module.Architecture,
AssemblyResolver = self.AssemblyResolver,
Kind = ModuleKind.Dll,
MetadataResolver = orig.Module.MetadataResolver,
Runtime = orig.Module.Runtime
}
);
MonoModder wrapperMod = new MonoModder()
{
Module = wrapper,
Logger = msg => self.Log("[MonoModRule] " + msg),
CleanupEnabled = false,
DependencyDirs = self.DependencyDirs,
MissingDependencyResolver = self.MissingDependencyResolver
};
wrapperMod.WriterParameters.WriteSymbols = false;
wrapperMod.WriterParameters.SymbolWriterProvider = null;
// Only add a copy of the map - adding the MMILRT asm itself to the map only causes issues.
wrapperMod.DependencyCache.AddRange(self.DependencyCache);
foreach (KeyValuePair <ModuleDefinition, List <ModuleDefinition> > mapping in self.DependencyMap)
{
wrapperMod.DependencyMap[mapping.Key] = new List <ModuleDefinition>(mapping.Value);
}
// Required as the relinker only deep-relinks if the method the type comes from is a mod.
// Fixes nasty reference import sharing issues.
wrapperMod.Mods.Add(self.Module);
wrapperMod.Relinker = (mtp, context) =>
mtp is TypeReference && ((TypeReference)mtp).IsMMILType() ?
MMILProxyManager.RelinkToProxy(wrapperMod, (TypeReference)mtp) :
mtp is TypeReference && ((TypeReference)mtp).FullName == orig.FullName ?
wrapper.GetType(orig.FullName) :
wrapperMod.DefaultRelinker(mtp, context);
wrapperMod.PrePatchType(orig, forceAdd: true);
wrapperMod.PatchType(orig);
TypeDefinition rulesCecil = wrapper.GetType(orig.FullName);
wrapperMod.PatchRefsInType(rulesCecil);
Assembly asm;
using (MemoryStream asmStream = new MemoryStream()) {
wrapperMod.Write(asmStream);
asm = Assembly.Load(asmStream.GetBuffer());
}
/**//*
* using (FileStream debugStream = File.OpenWrite(Path.Combine(
* self.DependencyDirs[0], $"{orig.Module.Name.Substring(0, orig.Module.Name.Length - 4)}.MonoModRules-MMILRT.dll")))
* wrapperMod.Write(debugStream);
* /**/
Type rules = asm.GetType(orig.FullName);
RuntimeHelpers.RunClassConstructor(rules.TypeHandle);
return(rules);
}
/// <summary>
/// Relink a .dll to point towards Celeste.exe and FNA / XNA properly at runtime, then load it.
/// </summary>
/// <param name="meta">The mod metadata, used for caching, among other things.</param>
/// <param name="stream">The stream to read the .dll from.</param>
/// <param name="depResolver">An optional dependency resolver.</param>
/// <param name="checksumsExtra">Any optional checksums. If you're running this at runtime, pass at least Everest.Relinker.GetChecksum(Metadata)</param>
/// <param name="prePatch">An optional step executed before patching, but after MonoMod has loaded the input assembly.</param>
/// <returns>The loaded, relinked assembly.</returns>
public static Assembly GetRelinkedAssembly(EverestModuleMetadata meta, Stream stream,
MissingDependencyResolver depResolver = null, string[] checksumsExtra = null, Action <MonoModder> prePatch = null)
{
if (!Flags.SupportRelinkingMods)
{
Logger.Log(LogLevel.Warn, "relinker", "Relinker disabled!");
return(null);
}
string cachedPath = GetCachedPath(meta);
string cachedChecksumPath = cachedPath.Substring(0, cachedPath.Length - 4) + ".sum";
string[] checksums = new string[2 + (checksumsExtra?.Length ?? 0)];
if (GameChecksum == null)
{
GameChecksum = Everest.GetChecksum(Assembly.GetAssembly(typeof(Relinker)).Location).ToHexadecimalString();
}
checksums[0] = GameChecksum;
checksums[1] = Everest.GetChecksum(meta).ToHexadecimalString();
if (checksumsExtra != null)
{
for (int i = 0; i < checksumsExtra.Length; i++)
{
checksums[i + 2] = checksumsExtra[i];
}
}
if (File.Exists(cachedPath) && File.Exists(cachedChecksumPath) &&
ChecksumsEqual(checksums, File.ReadAllLines(cachedChecksumPath)))
{
Logger.Log(LogLevel.Verbose, "relinker", $"Loading cached assembly for {meta}");
try {
return(Assembly.LoadFrom(cachedPath));
} catch (Exception e) {
Logger.Log(LogLevel.Warn, "relinker", $"Failed loading {meta}");
e.LogDetailed();
return(null);
}
}
if (depResolver == null)
{
depResolver = GenerateModDependencyResolver(meta);
}
try {
MonoModder modder = Modder;
modder.Input = stream;
modder.OutputPath = cachedPath;
modder.MissingDependencyResolver = depResolver;
string symbolPath;
modder.ReaderParameters.SymbolStream = OpenStream(meta, out symbolPath, meta.DLL.Substring(0, meta.DLL.Length - 4) + ".pdb", meta.DLL + ".mdb");
modder.ReaderParameters.ReadSymbols = modder.ReaderParameters.SymbolStream != null;
if (modder.ReaderParameters.SymbolReaderProvider != null &&
modder.ReaderParameters.SymbolReaderProvider is RelinkerSymbolReaderProvider)
{
((RelinkerSymbolReaderProvider)modder.ReaderParameters.SymbolReaderProvider).Format =
string.IsNullOrEmpty(symbolPath) ? DebugSymbolFormat.Auto :
symbolPath.EndsWith(".mdb") ? DebugSymbolFormat.MDB :
symbolPath.EndsWith(".pdb") ? DebugSymbolFormat.PDB :
DebugSymbolFormat.Auto;
}
modder.Read();
modder.ReaderParameters.ReadSymbols = false;
if (modder.ReaderParameters.SymbolReaderProvider != null &&
modder.ReaderParameters.SymbolReaderProvider is RelinkerSymbolReaderProvider)
{
((RelinkerSymbolReaderProvider)modder.ReaderParameters.SymbolReaderProvider).Format = DebugSymbolFormat.Auto;
}
modder.MapDependencies();
if (!RuntimeRulesParsed)
{
RuntimeRulesParsed = true;
InitMMSharedData();
string rulesPath = Path.Combine(
Path.GetDirectoryName(typeof(Celeste).Assembly.Location),
Path.GetFileNameWithoutExtension(typeof(Celeste).Assembly.Location) + ".Mod.mm.dll"
);
if (!File.Exists(rulesPath))
{
// Fallback if someone renamed Celeste.exe
rulesPath = Path.Combine(
Path.GetDirectoryName(typeof(Celeste).Assembly.Location),
"Celeste.Mod.mm.dll"
);
}
if (File.Exists(rulesPath))
{
ModuleDefinition rules = ModuleDefinition.ReadModule(rulesPath, new ReaderParameters(ReadingMode.Immediate));
modder.ParseRules(rules);
rules.Dispose(); // Is this safe?
}
// Fix old mods built against HookIL instead of ILContext.
_Modder.RelinkMap["MonoMod.RuntimeDetour.HookGen.ILManipulator"] = "MonoMod.Cil.ILContext/Manipulator";
_Modder.RelinkMap["MonoMod.RuntimeDetour.HookGen.HookIL"] = "MonoMod.Cil.ILContext";
_Modder.RelinkMap["MonoMod.RuntimeDetour.HookGen.HookILCursor"] = "MonoMod.Cil.ILCursor";
_Modder.RelinkMap["MonoMod.RuntimeDetour.HookGen.HookILLabel"] = "MonoMod.Cil.ILLabel";
_Modder.RelinkMap["MonoMod.RuntimeDetour.HookGen.HookExtensions"] = "MonoMod.Cil.ILPatternMatchingExt";
_Shim("MonoMod.Utils.ReflectionHelper", typeof(MonoModUpdateShim._ReflectionHelper));
_Shim("MonoMod.Cil.ILCursor", typeof(MonoModUpdateShim._ILCursor));
// If no entry for MonoMod.Utils exists already, add one.
modder.MapDependency(_Modder.Module, "MonoMod.Utils");
}
prePatch?.Invoke(modder);
modder.AutoPatch();
modder.Write();
} catch (Exception e) {
Logger.Log(LogLevel.Warn, "relinker", $"Failed relinking {meta}");
e.LogDetailed();
return(null);
} finally {
Modder.ClearCaches(moduleSpecific: true);
Modder.Module.Dispose();
Modder.Module = null;
Modder.ReaderParameters.SymbolStream?.Dispose();
}
if (File.Exists(cachedChecksumPath))
{
File.Delete(cachedChecksumPath);
}
File.WriteAllLines(cachedChecksumPath, checksums);
Logger.Log(LogLevel.Verbose, "relinker", $"Loading assembly for {meta}");
try {
return(Assembly.LoadFrom(cachedPath));
} catch (Exception e) {
Logger.Log(LogLevel.Warn, "relinker", $"Failed loading {meta}");
e.LogDetailed();
return(null);
}
}
