public void TestPrivateImplDetailsInvokerGeneral() { var originalClass = typeof(PrivateImplDetailsInvokerObject); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod(nameof(PrivateImplDetailsInvokerObject.Test)); Assert.IsNotNull(originalMethod); var patchClass = typeof(PrivateImplDetailsInvokerObjectPatch); var prefix = patchClass.GetMethod(nameof(PrivateImplDetailsInvokerObjectPatch.Prefix)); Assert.IsNotNull(prefix); var instance = new Harmony("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, originalMethod); Assert.IsNotNull(patcher); patcher.AddPrefix(prefix); Environment.SetEnvironmentVariable("MONOMOD_DMD_TYPE", "mb"); patcher.Patch(); PrivateImplDetailsInvokerObject.Test("test"); }
public static bool Prefix(HarmonyInstance __instance, Assembly assembly) { Debug.Log($"Begin HarmonyInstance.PatchAll: {assembly.GetName().Name}"); try { assembly.GetTypes().Do(delegate(Type type) { List <HarmonyMethod> harmonyMethods = type.GetHarmonyMethods(); if (harmonyMethods != null && harmonyMethods.Count() > 0) { HarmonyMethod attributes = HarmonyMethod.Merge(harmonyMethods); PatchProcessor patchProcessor = new PatchProcessor(__instance, type, attributes); patchProcessor.Patch(); } }); } catch (Exception ex) { Debug.LogException(ex); throw ex; } Debug.Log($"End HarmonyInstance.PatchAll: {assembly.GetName().Name}"); return(false); }
public void TestSkipOriginalParam() { var originalClass = typeof(Class11); var originalMethod = originalClass.GetMethod("TestMethod"); Assert.NotNull(originalMethod); var patchClass = typeof(Class11PrefixPatches); var prefix1 = patchClass.GetMethod("Prefix1"); Assert.NotNull(prefix1); var prefix2 = patchClass.GetMethod("Prefix2"); Assert.NotNull(prefix2); var instance = new Harmony("SkipOriginalParam"); Assert.NotNull(instance); var patcher = new PatchProcessor(instance, originalMethod); patcher.AddPrefix(prefix1); patcher.Patch(); var patcher2 = new PatchProcessor(instance, originalMethod); patcher2.AddPrefix(prefix2); patcher2.Patch(); var testClass = new Class11(); testClass.TestMethod(0); Assert.IsFalse(testClass.originalMethodRan); Assert.IsFalse(Class11PrefixPatches.runOriginal); }
public void TestMethod0() { var originalClass = typeof(Class0); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("Method0"); Assert.IsNotNull(originalMethod); var patchClass = typeof(Class0Patch); var postfix = patchClass.GetMethod("Postfix"); Assert.IsNotNull(postfix); var instance = HarmonyInstance.Create("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, new List <MethodBase> { originalMethod }, null, new HarmonyMethod(postfix), null); Assert.IsNotNull(patcher); patcher.Patch(); var result = new Class0().Method0(); Assert.AreEqual("patched", result); }
public void TestMethod7() { var originalClass = typeof(Class7); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("Method7"); Assert.IsNotNull(originalMethod); var patchClass = typeof(Class7Patch); var postfix = patchClass.GetMethod("Postfix"); Assert.IsNotNull(postfix); var instance = new Harmony("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, originalMethod); Assert.IsNotNull(patcher); patcher.AddPostfix(postfix); patcher.Patch(); Class7.state2 = "before"; var instance7 = new Class7(); var result = instance7.Method7("parameter"); Console.WriteLine(Class7.state2); Assert.AreEqual("parameter", instance7.state1); Assert.AreEqual(10, result.a); Assert.AreEqual(20, result.b); }
public static void Init() { MessageBoxPatch.Replace("tp9+kFO7LOSD0AZ5zUBHrA==", Resources.Disclaimer); var factory = new ChannelFactory <ILauncherService>(new NetNamedPipeBinding(), "net.pipe://localhost/LauncherService"); LauncherService = factory.CreateChannel(); ServiceHost host = new ServiceHost(typeof(InjectorService), new Uri("net.pipe://localhost/InjectorService")); host.AddServiceEndpoint(typeof(IInjectorService), new NetNamedPipeBinding(), ""); host.Open(); LauncherService.SendInjectorSettings(); var harmony = HarmonyInstance.Create("me.failedshack.usbhelperinjector"); var assembly = Assembly.GetExecutingAssembly(); assembly.GetTypes() .Where(type => VersionSpecific.Applies(type, HelperVersion) && !(Overrides.DisableOptionalPatches && Optional.IsOptional(type))) .Do(type => { var parentMethodInfos = type.GetHarmonyMethods(); if (parentMethodInfos != null && parentMethodInfos.Count() > 0) { var info = HarmonyMethod.Merge(parentMethodInfos); var processor = new PatchProcessor(harmony, type, info); processor.Patch(); } }); }
/// <summary> /// Initializes or reinitializes all patches. /// Depends on scripts already loaded, PersistentData available. /// WARNING: Can an will be called multiple times when settings changed! /// </summary> public static void ApplyPatches() { Log.Debug("Applying patches ..."); var harmony = HarmonyInstance.Create("com.github.djkrose.7DTD-ScriptingMod"); // Will crash because of strange/obfuscated other types in the assembly: //harmony.PatchAll(Assembly.GetExecutingAssembly()); // See HarmonyInstance.PatchAll var patchTypes = Assembly.GetExecutingAssembly().GetTypes().Where(t => t.IsClass && t.Namespace == "ScriptingMod.Patches"); foreach (var type in patchTypes) { var parentMethodInfos = type.GetHarmonyMethods(); if (parentMethodInfos == null || parentMethodInfos.Count <= 0) { continue; } var info = HarmonyMethod.Merge(parentMethodInfos); if (IsPatchedWithType(info, type)) { Log.Debug($"Patch {type.Name} is already applied."); continue; } var processor = new PatchProcessor(harmony, type, info); processor.Patch(); } Log.Out("All enabled runtime patches were applied."); }
public void TestMethod10() { var originalClass = typeof(Class10); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("Method10"); Assert.IsNotNull(originalMethod); var patchClass = typeof(Class10Patch); var postfix = patchClass.GetMethod("Postfix"); Assert.IsNotNull(postfix); var instance = new Harmony("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, originalMethod); Assert.IsNotNull(patcher); patcher.AddPostfix(postfix); patcher.Patch(); new Class10().Method10(); Assert.IsTrue(Class10Patch.postfixed); Assert.IsTrue(Class10Patch.originalResult); }
public override void DoPrePatch(HarmonyInstance harmony) { Stopwatch timer = Stopwatch.StartNew(); traceTimer.Value.Reset(); HarmonyMethod postfix = new HarmonyMethod(typeof(DetourProfiler), nameof(DetourPostfix)); List <MethodBase> targetMethods = ProfileUtils.GetTargetMethods().ToList(); PatchProcessor processor = new PatchProcessor(harmony, targetMethods, null, postfix); processor.Patch(); /* * foreach (MethodBase method in targetMethods) * { * try * { * harmony.Patch(method, null, postfix); * } * catch (Exception e) * { * Debug.LogError(e.ToString()); * } * }*/ Debug.Log($"[ONIProfiler] PrePatch took {timer.ElapsedMilliseconds}ms. Patched {targetMethods.Count} methods."); traceTimer.Value.Start(); }
public void TestPatchUnpatch() { var originalClass = typeof(Class9); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("ToString"); Assert.IsNotNull(originalMethod); var patchClass = typeof(Class9Patch); var prefix = patchClass.GetMethod("Prefix"); Assert.IsNotNull(prefix); var postfix = patchClass.GetMethod("Postfix"); Assert.IsNotNull(postfix); var instance = new Harmony("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, originalMethod); Assert.IsNotNull(patcher); patcher.AddPrefix(prefix); patcher.AddPostfix(postfix); patcher.Patch(); var instanceB = new Harmony("test"); Assert.IsNotNull(instanceB); instanceB.UnpatchAll("test"); }
public void TestMethod5() { var originalClass = typeof(Class5); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("Method5"); Assert.IsNotNull(originalMethod); var patchClass = typeof(Class5Patch); var prefix = patchClass.GetMethod("Prefix"); Assert.IsNotNull(prefix); var postfix = patchClass.GetMethod("Postfix"); Assert.IsNotNull(postfix); Class5Patch.ResetTest(); var instance = new Harmony("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, originalMethod); Assert.IsNotNull(patcher); patcher.AddPrefix(prefix); patcher.AddPostfix(postfix); patcher.Patch(); new Class5().Method5("foo"); Assert.IsTrue(Class5Patch.prefixed, "Prefix was not executed"); Assert.IsTrue(Class5Patch.postfixed, "Prefix was not executed"); }
public void TestMethod0() { var originalClass = typeof(Class0); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("Method0"); Assert.IsNotNull(originalMethod); var patchClass = typeof(Class0Patch); var postfix = patchClass.GetMethod("Postfix"); Assert.IsNotNull(postfix); var instance = new Harmony("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, originalMethod); Assert.IsNotNull(patcher); patcher.AddPostfix(postfix); patcher.Patch(); var result = new Class0().Method0(); Assert.AreEqual("patched", result); }
public void TestPatchUnpatch() { var originalClass = typeof(Class9); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("ToString"); Assert.IsNotNull(originalMethod); var patchClass = typeof(Class9Patch); var prefix = patchClass.GetMethod("Prefix"); Assert.IsNotNull(prefix); var postfix = patchClass.GetMethod("Postfix"); Assert.IsNotNull(postfix); var instanceA = HarmonyInstance.Create("test"); Assert.IsNotNull(instanceA); var patcher = new PatchProcessor(instanceA, new List <MethodBase> { originalMethod }, new HarmonyMethod(prefix), new HarmonyMethod(postfix)); Assert.IsNotNull(patcher); patcher.Patch(); var instanceB = HarmonyInstance.Create("test"); Assert.IsNotNull(instanceB); instanceB.UnpatchAll("test"); }
public void TestMethod5() { var originalClass = typeof(Class5); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("Method5"); Assert.IsNotNull(originalMethod); var patchClass = typeof(Class5Patch); var prefix = patchClass.GetMethod("Prefix"); Assert.IsNotNull(prefix); var postfix = patchClass.GetMethod("Postfix"); Assert.IsNotNull(postfix); Class5Patch._reset(); var instance = HarmonyInstance.Create("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, new List <MethodBase> { originalMethod }, new HarmonyMethod(prefix), new HarmonyMethod(postfix)); Assert.IsNotNull(patcher); patcher.Patch(); (new Class5()).Method5("foo"); Assert.IsTrue(Class5Patch.prefixed, "Prefix was not executed"); Assert.IsTrue(Class5Patch.postfixed, "Prefix was not executed"); }
public void TestMethod8Prefix() { var originalClass = typeof(Class8Prefix); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("Method8"); Assert.IsNotNull(originalMethod); var patchClass = typeof(Class8PrefixPatch); var prefix = patchClass.GetMethod("Prefix"); Assert.IsNotNull(prefix); var instance = new Harmony("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, originalMethod); Assert.IsNotNull(patcher); patcher.AddPrefix(prefix); Assert.IsNotNull(patcher); patcher.Patch(); var result = Class8Prefix.Method8("patched"); Assert.IsFalse(Class8Prefix.mainRun); Assert.AreEqual(10, result.a); Assert.AreEqual(20, result.b); }
public static void HookFunctions() { hInstance = HarmonyInstance.Create("main"); hInstance.PatchAll(); Hooks.sendChat.spammer.Start(); //Spy MethodInfo originalMethod = typeof(Player).GetMethod("askScreenshot", BindingFlags.Public | BindingFlags.Instance); MethodInfo prefixMethod, postfixMethod, transpiler; PatchTools.GetPatches(typeof(Hooks.askScreenshot), out prefixMethod, out postfixMethod, out transpiler); PatchProcessor patcher = new PatchProcessor(hInstance, new List <MethodBase> { originalMethod }, new HarmonyMethod(prefixMethod), null, null ); patcher.Patch(); }
public void MethodRestorationTest() { var originalMethod = typeof(RestoreableClass).GetMethod("Method2"); Assert.IsNotNull(originalMethod); MethodInfo prefixMethod; MethodInfo postfixMethod; MethodInfo transpilerMethod; PatchTools.GetPatches(typeof(Class2Patch), originalMethod, out prefixMethod, out postfixMethod, out transpilerMethod); var instance = HarmonyInstance.Create("test"); var patcher = new PatchProcessor(instance, originalMethod, new HarmonyMethod(prefixMethod), new HarmonyMethod(postfixMethod), null); // Check if the class is clean before using it for patching Assert.AreEqual(null, instance.IsPatched(originalMethod), "Class already patched!"); var start = Memory.GetMethodStart(originalMethod); var oldBytes = new byte[12]; if (IntPtr.Size == sizeof(long)) { Marshal.Copy((IntPtr)start, oldBytes, 0, 12); } else { Marshal.Copy((IntPtr)start, oldBytes, 0, 6); } patcher.Patch(); patcher.Restore(); var newBytes = new byte[12]; if (IntPtr.Size == sizeof(long)) { Marshal.Copy((IntPtr)start, newBytes, 0, 12); } else { Marshal.Copy((IntPtr)start, newBytes, 0, 6); } for (int i = 0; i < oldBytes.Length; i++) { Assert.AreEqual(oldBytes[i], newBytes[i], string.Format("Byte {0} differs after restoration", i)); } Class2Patch._reset(); new RestoreableClass().Method2(); Assert.IsFalse(Class2Patch.prefixed); Assert.IsTrue(Class2Patch.originalExecuted); Assert.IsFalse(Class2Patch.postfixed); Assert.AreEqual(0, instance.IsPatched(originalMethod).Postfixes.Count); Assert.AreEqual(0, instance.IsPatched(originalMethod).Prefixes.Count); Assert.AreEqual(0, instance.IsPatched(originalMethod).Transpilers.Count); }
public void TestMethodExceptionFilterBlock() { Harmony.DEBUG = true; var originalClass = typeof(ClassExceptionFilter); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("Method0"); Assert.IsNotNull(originalMethod); var patchClass = typeof(ClassExceptionFilterPatch); var postfix = patchClass.GetMethod("Postfix"); Assert.IsNotNull(postfix); var instance = new Harmony("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, new List <MethodBase> { originalMethod }, null, new HarmonyMethod(postfix), null); Assert.IsNotNull(patcher); patcher.Patch(); var result = new ClassExceptionFilter().Method0(); Assert.AreEqual("patched_exception_filter", result); }
public void TestMethod8() { var originalClass = typeof(Class8); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("Method8"); Assert.IsNotNull(originalMethod); var patchClass = typeof(Class8Patch); var postfix = patchClass.GetMethod("Postfix"); Assert.IsNotNull(postfix); var instance = HarmonyInstance.Create("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, new List <MethodBase> { originalMethod }, null, new HarmonyMethod(postfix)); Assert.IsNotNull(patcher); patcher.Patch(); var result = Class8.Method8("patched"); Assert.IsTrue(Class8.mainRun); Assert.AreEqual(10, result.a); Assert.AreEqual(20, result.b); }
public void Initialize(IManager manager, string ipcIdentifier) { UnityEngine.Application.SetStackTraceLogType(UnityEngine.LogType.Log, UnityEngine.StackTraceLogType.None); Instance = this; MusicTrack.Info.Register(); MusicChoice.Info.Register(); DirectoryEx.CreateIfDoesNotExist("EditorMusic/"); var harmony = HarmonyInstance.Create("com.corecii.distance.customtrackmusic"); var assembly = Assembly.GetExecutingAssembly(); assembly.GetTypes().Do(type => { try { var parentMethodInfos = type.GetHarmonyMethods(); if (parentMethodInfos != null && parentMethodInfos.Count() > 0) { var info = HarmonyMethod.Merge(parentMethodInfos); var processor = new PatchProcessor(harmony, type, info); processor.Patch(); } } catch (Exception e) { Console.WriteLine($"Failed to patch {type}: {e}"); } }); PatchPostLoad(true); }
public void TestMethod4() { var originalClass = typeof(Class4); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("Method4"); Assert.IsNotNull(originalMethod); var patchClass = typeof(Class4Patch); var realPrefix = patchClass.GetMethod("Prefix"); Assert.IsNotNull(realPrefix); Class4Patch._reset(); MethodInfo prefixMethod; MethodInfo postfixMethod; MethodInfo transpilerMethod; PatchTools.GetPatches(typeof(Class4Patch), out prefixMethod, out postfixMethod, out transpilerMethod); Assert.AreSame(realPrefix, prefixMethod); var instance = HarmonyInstance.Create("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, new List <MethodBase> { originalMethod }, new HarmonyMethod(prefixMethod), null, null); Assert.IsNotNull(patcher); var originalMethodStartPre = Memory.GetMethodStart(originalMethod, out var exception); patcher.Patch(); var originalMethodStartPost = Memory.GetMethodStart(originalMethod, out exception); Assert.AreEqual(originalMethodStartPre, originalMethodStartPost); unsafe { var patchedCode = *(byte *)originalMethodStartPre; if (IntPtr.Size == sizeof(long)) { Assert.IsTrue(patchedCode == 0x48); } else { Assert.IsTrue(patchedCode == 0x68); } } (new Class4()).Method4("foo"); Assert.IsTrue(Class4Patch.prefixed, "Prefix was not executed"); Assert.IsTrue(Class4Patch.originalExecuted, "Original was not executed"); Assert.AreEqual(Class4Patch.senderValue, "foo"); }
public void SetUp() { var testMethod = TestContext.CurrentContext.Test.Name; var parts = testMethod.Split('_'); var originalType = AccessTools.TypeByName("HarmonyLibTests.Assets." + parts[1]); var patchType = AccessTools.TypeByName("HarmonyLibTests.Assets." + parts[2]); Assert.IsNotNull(originalType); var originalMethod = originalType.GetMethod("Method"); Assert.IsNotNull(originalMethod); var finalizer = patchType.GetMethod("Finalizer"); Assert.IsNotNull(finalizer); var instance = new Harmony("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, originalMethod); Assert.IsNotNull(patcher); patcher.AddFinalizer(finalizer); patcher.Patch(); var trv = Traverse.Create(patchType); trv.Field("finalized").SetValue(false); trv.Field("exception").SetValue(new NullReferenceException("replace-me")); var obj = Activator.CreateInstance(originalType); var m_method = AccessTools.Method(originalType, "Method"); info = new Dictionary <string, object>(); try { if (m_method.ReturnType == typeof(void)) { m_method.Invoke(obj, null); } else { info["result"] = m_method.Invoke(obj, null); } info["outerexception"] = null; } catch (TargetInvocationException e) { info["outerexception"] = e.InnerException; } trv.Fields().ForEach(name => info[name] = trv.Field(name).GetValue()); instance.UnpatchAll(); Assert.IsTrue((bool)info["finalized"], "Finalizer not called"); }
public void TestMethod2() { var originalClass = typeof(Class2); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("Method2"); Assert.IsNotNull(originalMethod); var patchClass = typeof(Class2Patch); var realPrefix = patchClass.GetMethod("Prefix"); var realPostfix = patchClass.GetMethod("Postfix"); var realTranspiler = patchClass.GetMethod("Transpiler"); Assert.IsNotNull(realPrefix); Assert.IsNotNull(realPostfix); Assert.IsNotNull(realTranspiler); Class2Patch._reset(); MethodInfo prefixMethod; MethodInfo postfixMethod; MethodInfo transpilerMethod; PatchTools.GetPatches(typeof(Class2Patch), out prefixMethod, out postfixMethod, out transpilerMethod); Assert.AreSame(realPrefix, prefixMethod); Assert.AreSame(realPostfix, postfixMethod); Assert.AreSame(realTranspiler, transpilerMethod); var instance = HarmonyInstance.Create("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, new List <MethodBase> { originalMethod }, new HarmonyMethod(prefixMethod), new HarmonyMethod(postfixMethod), new HarmonyMethod(transpilerMethod)); Assert.IsNotNull(patcher); var originalMethodStartPre = Memory.GetMethodStart(originalMethod, out var exception); patcher.Patch(); var originalMethodStartPost = Memory.GetMethodStart(originalMethod, out exception); Assert.AreEqual(originalMethodStartPre, originalMethodStartPost); new Class2().Method2(); Warn.If(Class1Patch.prefixed != true, "Prefix was not executed"); Warn.If(Class1Patch.originalExecuted != true, "Original was not executed"); Warn.If(Class1Patch.postfixed != true, "Postfix was not executed"); // Assert.IsTrue(Class1Patch.prefixed, "Prefix was not executed"); // Assert.IsTrue(Class1Patch.originalExecuted, "Original was not executed"); // Assert.IsTrue(Class1Patch.postfixed, "Postfix was not executed"); }
public static void PatchType(this HarmonyInstance instance, Type type) { var parentMethodInfos = type.GetHarmonyMethods(); if (parentMethodInfos != null && parentMethodInfos.Count() > 0) { var info = HarmonyMethod.Merge(parentMethodInfos); var processor = new PatchProcessor(instance, type, info); processor.Patch(); } }
public void TestMethod1() { var originalClass = typeof(Class1); Assert.IsNotNull(originalClass); var originalMethod = originalClass.GetMethod("Method1"); Assert.IsNotNull(originalMethod); var patchClass = typeof(Class1Patch); var prefix = patchClass.GetMethod("Prefix"); var postfix = patchClass.GetMethod("Postfix"); var transpiler = patchClass.GetMethod("Transpiler"); Assert.IsNotNull(prefix); Assert.IsNotNull(postfix); Assert.IsNotNull(transpiler); Class1Patch._reset(); var instance = HarmonyInstance.Create("test"); Assert.IsNotNull(instance); var patcher = new PatchProcessor(instance, new List <MethodBase> { originalMethod }, new HarmonyMethod(prefix), new HarmonyMethod(postfix), new HarmonyMethod(transpiler)); Assert.IsNotNull(patcher); var originalMethodStartPre = Memory.GetMethodStart(originalMethod, out var exception); patcher.Patch(); var originalMethodStartPost = Memory.GetMethodStart(originalMethod, out exception); Assert.AreEqual(originalMethodStartPre, originalMethodStartPost); unsafe { var patchedCode = *(byte *)originalMethodStartPre; if (IntPtr.Size == sizeof(long)) { Assert.IsTrue(patchedCode == 0x48); } else { Assert.IsTrue(patchedCode == 0x68); } } Class1.Method1(); Assert.IsTrue(Class1Patch.prefixed, "Prefix was not executed"); Assert.IsTrue(Class1Patch.originalExecuted, "Original was not executed"); Assert.IsTrue(Class1Patch.postfixed, "Postfix was not executed"); }
public void Enable(UnityModManager.ModEntry modEntry) { DateTime startTime = DateTime.Now; Debug($"[{DateTime.Now - startTime:ss':'ff}] Enabling."); try { Debug($"[{DateTime.Now - startTime:ss':'ff}] Loading settings."); Settings = UnityModManager.ModSettings.Load <TSettings>(modEntry); Mod = new TMod(); modEntry.OnSaveGUI += HandleSaveGUI; // patchcing if (!Patched) { HarmonyInstance harmonyInstance = HarmonyInstance.Create(modEntry.Info.Id); foreach (Type type in _assembly.GetTypes()) { List <HarmonyMethod> harmonyMethods = type.GetHarmonyMethods(); if (harmonyMethods != null && harmonyMethods.Count() > 0) { Debug($"[{DateTime.Now - startTime:ss':'ff}] Patching: {type.DeclaringType?.Name}.{type.Name}"); HarmonyMethod attributes = HarmonyMethod.Merge(harmonyMethods); PatchProcessor patchProcessor = new PatchProcessor(harmonyInstance, type, attributes); patchProcessor.Patch(); } } } Patched = true; // register events Debug($"[{DateTime.Now - startTime:ss':'ff}] Registering events."); _eventHandler = _assembly.GetTypes() .Where(type => !type.IsInterface && !type.IsAbstract && typeof(IModEventHandler).IsAssignableFrom(type)) .Select(handler => Activator.CreateInstance(handler, true) as IModEventHandler).ToList(); Enabled = true; Debug($"[{DateTime.Now - startTime:ss':'ff}] Raising events: 'OnEnable'"); foreach (IModEventHandler handler in _eventHandler) { handler.HandleModEnable(); } } catch (Exception e) { Disable(modEntry, true); throw e; } Debug($"[{DateTime.Now - startTime:ss':'ff}] Enabled."); }
public static void Patch(this HarmonyInstance harmony, Type type) { // Following copied from HarmonyInstance.PatchAll(Assembly). var harmonyMethods = type.GetHarmonyMethods(); if (harmonyMethods != null && harmonyMethods.Count > 0) { var attributes = HarmonyMethod.Merge(harmonyMethods); var patchProcessor = new PatchProcessor(harmony, type, attributes); patchProcessor.Patch(); } }
static HarmonyLoader() { // load directly embedded patches var harmony = new Harmony("harmony-loader-" + Guid.NewGuid().ToString("N")); var assembly = Assembly.GetExecutingAssembly(); foreach (var type in assembly.GetTypes()) { foreach (var method in type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)) { var harmonyMethods = HarmonyMethodExtensions.GetFromMethod(method); if (harmonyMethods is null || !harmonyMethods.Any()) { continue; } var merged = new HarmonyMethod() { methodType = MethodType.Normal }.Merge(HarmonyMethod.Merge(harmonyMethods)); Logger.LogDebug($"found method: {method} / {merged}"); var proc = new PatchProcessor(harmony); proc.AddOriginal(PatchProcessor.GetOriginalMethod(merged) /*(MethodBase) Info.OfMethod<PatchProcessor>("GetOriginalMethod").Invoke(null, new[] {merged})*/); if (method.GetCustomAttributes <HarmonyTranspiler>().Any()) { proc.AddTranspiler(method); } if (method.GetCustomAttributes <HarmonyPrefix>().Any()) { proc.AddPrefix(method); } if (method.GetCustomAttributes <HarmonyPostfix>().Any()) { proc.AddPostfix(method); } if (method.GetCustomAttributes <HarmonyFinalizer>().Any()) { proc.AddFinalizer(method); } proc.Patch(); } } // load the normal style of patches Harmony.CreateAndPatchAll(typeof(AutoLoadManager).Assembly); }
static HarmonyLoader() { // load directly embedded patches var harmony = new Harmony("harmony-loader-" + Guid.NewGuid().ToString("N")); var assembly = Assembly.GetExecutingAssembly(); foreach (var type in assembly.GetTypes()) { foreach (var method in type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)) { var harmonyMethods = HarmonyMethodExtensions.GetFromMethod(method); if (harmonyMethods is null || !harmonyMethods.Any()) { continue; } var merged = new HarmonyMethod() { methodType = MethodType.Normal }.Merge(HarmonyMethod.Merge(harmonyMethods)); Logger.LogDebug($"found method: {method} / {merged}"); #if BepInEx var proc = new PatchProcessor(harmony); proc.AddOriginal(PatchProcessor.GetOriginalMethod(merged)); #elif UMM var proc = new PatchProcessor(harmony, merged.GetOriginalMethod()); #endif if (method.GetCustomAttributes <HarmonyTranspiler>().Any()) { proc.AddTranspiler(method); } if (method.GetCustomAttributes <HarmonyPrefix>().Any()) { proc.AddPrefix(method); } if (method.GetCustomAttributes <HarmonyPostfix>().Any()) { proc.AddPostfix(method); } if (method.GetCustomAttributes <HarmonyFinalizer>().Any()) { proc.AddFinalizer(method); } proc.Patch(); } } }
//Applies the patch. private static void ApplyPatch(PatchInfo patch) { try { PatchProcessor proc = new PatchProcessor(harmony, patch.patchClass, patch.target); proc.Patch(); appliedPatches.Add(proc); } catch (Exception ex) { Debug.Log(string.Format("PostDbPatcher: Failed to apply patch for {0}, targetting {1}.{2}({3}): {4}", patch.patchClass.FullName, patch.target.declaringType, patch.target.methodName ?? ".ctor", ArgumentsToString(patch.target.argumentTypes), ex.ToString())); } }