public bool IsApplicable(Game game)
{
var patchInfo = Harmony.GetPatchInfo(TargetMethodInfo);
if (AlreadyPatchedByOthers(patchInfo))
{
return(false);
}
var bytes = TargetMethodInfo.GetCilBytes();
if (bytes == null)
{
return(false);
}
var hash = bytes.GetSha256();
return(hash.SequenceEqual(new byte[] {
0x4C, 0x29, 0xDC, 0x2D, 0x78, 0x89, 0xA7, 0xA8,
0xC6, 0xDA, 0x84, 0xDB, 0x07, 0x2E, 0x7D, 0xB4,
0x99, 0xED, 0xB2, 0xB9, 0xC4, 0xBB, 0xAD, 0xE4,
0xC9, 0xD1, 0xC8, 0x0F, 0xD7, 0x8C, 0x25, 0x15
}));
}
public static void DoPatches(HarmonyLib.Harmony harm)
{
harm.Patch(AccessTools.Method(typeof(Verb), "OrderForceTarget"),
new HarmonyMethod(typeof(VerbPatches), "Prefix_OrderForceTarget"));
harm.Patch(AccessTools.Method(typeof(Verb), "get_EquipmentSource"),
new HarmonyMethod(typeof(VerbPatches), "Prefix_EquipmentSource"));
}
static MeatShieldPatcher()
{
var tp = typeof(CoverUtils);
BindingFlags attrs = BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public;
FillageMethodReplacer = tp.GetMethod(nameof(CoverUtils.GetFillage), attrs);
FillPercentageReplacer = tp.GetMethod(nameof(CoverUtils.GetFillPercentage), attrs);
FillPercentageTarget = typeof(ThingDef).GetField(nameof(ThingDef.fillPercent), attrs);
BaseBlockChanceReplacer = typeof(CoverUtils).GetMethod(nameof(CoverUtils.BaseBlockChance));
BaseBlockChanceTarget =
typeof(CoverUtility).GetMethod(nameof(CoverUtility.BaseBlockChance), new Type[] { typeof(ThingDef) });
FillageTarget = typeof(ThingDef)
.GetProperty(nameof(ThingDef.Fillage),
attrs)
.GetGetMethod();
ThingDefField = typeof(Thing).GetField(nameof(Thing.def));
TranspilerMI = typeof(MeatShieldPatcher).GetMethod(nameof(Transpiler), attrs);
var harmony = new HarmonyLib.Harmony(MeatShieldMod.MOD_ID);
harmony.PatchAll();
MassPatch(harmony);
}
public static bool CheckForCompetition(this HarmonyLib.Patches patches, HarmonyLib.Harmony domesticHarmoy, out string debugInfo, ReadOnlyCollection <string> ignoreList = null)
{
bool Result = CheckForCompetition(patches, domesticHarmoy, out StringBuilder debugInfoBuilder, ignoreList);
debugInfo = debugInfoBuilder.ToString();
return(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 = new HarmonyLib.Harmony("test");
Assert.IsNotNull(instance);
var patcher = instance.CreateProcessor(originalMethod);
Assert.IsNotNull(patcher);
patcher.AddPostfix(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 static void Apply()
{
if (Utility.CurrentOs == Platform.Windows)
{
return;
}
if (typeof(Console).Assembly.GetType("System.ConsoleDriver") == null)
{
// Mono version is too old, use our own TTY implementation instead
return;
}
if (AccessTools.Method("System.TermInfoReader:DetermineVersion") != null)
{
// Fix has been applied officially
return;
}
var harmony = new HarmonyLib.Harmony("com.bepinex.xtermfix");
harmony.Patch(AccessTools.Method("System.TermInfoReader:ReadHeader"),
prefix: new HarmonyMethod(typeof(XTermFix), nameof(ReadHeaderPrefix)));
harmony.Patch(AccessTools.Method("System.TermInfoReader:Get", new [] { AccessTools.TypeByName("System.TermInfoNumbers") }),
transpiler: new HarmonyMethod(typeof(XTermFix), nameof(GetTermInfoNumbersTranspiler)));
harmony.Patch(AccessTools.Method("System.TermInfoReader:Get", new [] { AccessTools.TypeByName("System.TermInfoStrings") }),
transpiler: new HarmonyMethod(typeof(XTermFix), nameof(GetTermInfoStringsTranspiler)));
harmony.Patch(AccessTools.Method("System.TermInfoReader:GetStringBytes", new [] { AccessTools.TypeByName("System.TermInfoStrings") }),
transpiler: new HarmonyMethod(typeof(XTermFix), nameof(GetTermInfoStringsTranspiler)));
}
static Harmony_Werewolf()
{
HarmonyLib.Harmony harmony = new HarmonyLib.Harmony("rimworld.facialstuff.werewolf_patch");
try
{
((Action)(() =>
{
if (AccessTools.Method(
typeof(WerewolfUtility),
nameof(WerewolfUtility.IsClean)) == null)
{
return;
}
harmony.Patch(
AccessTools.Method(typeof(CompWerewolf), nameof(CompWerewolf.TransformInto)),
new HarmonyMethod(typeof(Werewolf_Patches), nameof(Werewolf_Patches.TransformInto_Prefix)),
null);
harmony.Patch(
AccessTools.Method(typeof(CompWerewolf), nameof(CompWerewolf.TransformBack)),
null,
new HarmonyMethod(
typeof(Werewolf_Patches),
nameof(Werewolf_Patches.TransformBack_Postfix)));
}))();
}
catch (TypeLoadException)
{
}
}
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 HarmonyLib.Harmony("test");
Assert.IsNotNull(instance);
var patcher = instance.CreateProcessor(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);
}
/// <summary>
/// Unpatches patch.
/// </summary>
public static void SafeUnpatch(this HarmonyLib.Harmony harmony, Type patchType)
{
var metadata = patchType.GetCustomAttribute <SafePatchAttribute>();
if (metadata == null)
{
ADOLib.Log($"Type {patchType} doesn't have SafePatch attribute.");
return;
}
ADOLib.Log($"Unpatching {metadata.PatchId}");
if (!metadata.IsEnabled)
{
ADOLib.Log($"{metadata.PatchId} is not patched!", LogType.Warning);
return;
}
var classType = metadata.Assembly.GetType(metadata.ClassName);
if (classType == null)
{
ADOLib.Log($"Type {metadata.ClassName} not found in assembly {metadata.Assembly}.");
return;
}
var original = metadata.info.method;
foreach (var patch in patchType.GetMethods())
{
harmony.Unpatch(original, patch);
}
metadata.IsEnabled = false;
ADOLib.Log($"Successfully unpatched {metadata.PatchId}", LogType.Success);
}
public static void PatchCategory(this HarmonyLib.Harmony harmony, Type type)
{
ADOLib.Log($"Patching category {type}");
var patchAttr = type.GetCustomAttribute <CategoryAttribute>();
if (!patchAttr.isValid)
{
ADOLib.Log($"{type} is not valid for this ADOFAI version", LogType.Warning);
return;
}
var patchClass = patchAttr.PatchClass;
if (patchClass == null)
{
ADOLib.Log($"No patch class found in category {type}", LogType.Warning);
return;
}
var patches = patchClass.GetNestedTypes(AccessTools.all).Where(t => t.GetCustomAttribute <SafePatchAttribute>() != null);
foreach (var p in patches)
{
harmony.SafePatch(p);
}
ADOLib.Log($"Successfully patched category {type}", LogType.Success);
}
public static void DoExtraEquipmentPatches(HarmonyLib.Harmony harm)
{
harm.Patch(AccessTools.Method(typeof(ThingDef), "get_IsRangedWeapon"),
new HarmonyMethod(typeof(MiscPatches), "Prefix_IsRangedWeapon"));
harm.Patch(AccessTools.Method(typeof(FloatMenuMakerMap), "AddDraftedOrders"),
transpiler: new HarmonyMethod(typeof(MiscPatches), "CheckForMelee"));
}
public static HarmonyLib.Harmony instance; //Lt. Bob: 1.1
static HarmonyMain()
{
//instance = HarmonyInstance.Create("DrCarlLuo.Rimworld.PreemptiveStrike"); //Lt. Bob: 1.1 - Replaced with below
instance = new HarmonyLib.Harmony("DrCarlLuo.Rimworld.PreemptiveStrike"); //Lt. Bob: 1.1
instance.PatchAll(Assembly.GetExecutingAssembly());
ManualPatchings();
}
public void DoPatching()
{
var harmony = new HarmonyLib.Harmony("com.configfreaks.bundlepatcher");
var assembly = typeof(AbstractGame).Assembly;
var types = assembly.GetTypes();
var nodeInterfaceType = types.First(x => x.IsInterface && x.GetProperty("SameNameAsset") != null);
_loaderType = types.First(x => x.IsClass && x.GetProperty("SameNameAsset") != null);
_bundleLockConstructor = types.First(x => x.IsClass && x.GetProperty("MaxConcurrentOperations") != null).GetConstructors().First();
_loadState = _loaderType.GetProperty("LoadState");
_loadStateProperty = _loadState.PropertyType.GetProperty("Value");
_bundleField = _loaderType.GetField("assetBundle_0", BindingFlags.Instance | BindingFlags.NonPublic);
_taskField = _loaderType.GetField("task_0", BindingFlags.Instance | BindingFlags.NonPublic);
var originalLoader = _loaderType.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic).First(x => x.GetParameters().Length == 0 && x.ReturnType == typeof(Task));
var _loaderConstructor = _loaderType.GetConstructors().First();
var getNodeType = types
.First(x => x.IsClass && x.GetMethod("GetNode") != null && string.IsNullOrWhiteSpace(x.Namespace)).MakeGenericType(nodeInterfaceType);
var originalGetNodeConstructor = getNodeType.GetConstructors().First();
var loaderPrefix = typeof(Loader).GetMethod("LoaderPrefix", BindingFlags.Static | BindingFlags.Public);
var loaderConstructor =
typeof(Loader).GetMethod(nameof(LoaderConstructor), BindingFlags.Static | BindingFlags.Public);
var getNodeContructor =
typeof(Loader).GetMethod(nameof(NodeConstructor), BindingFlags.Static | BindingFlags.Public);
harmony.Patch(originalLoader, new HarmonyMethod(loaderPrefix));
harmony.Patch(_loaderConstructor, new HarmonyMethod(loaderConstructor));
harmony.Patch(originalGetNodeConstructor, new HarmonyMethod(getNodeContructor));
}
public static bool LoadRimHUDCompatibility(HarmonyLib.Harmony instance, ModContentPack mod)
{
Assembly rimhudAssembly = mod.assemblies.loadedAssemblies.FirstOrDefault((Assembly assembly) => assembly.GetName().Name == "RimHUD");
if (rimhudAssembly == null)
{
Log.Message("banish.animals : RimHUD installed, but not loaded or unexpected AssemblyName", false);
}
else
{
System.Type type = rimhudAssembly.GetType("RimHUD.Interface.InspectPanePlus");
if (type != null)
{
MethodInfo method = type.GetMethod("DrawButtons", BindingFlags.Static | BindingFlags.NonPublic);
if (method != null)
{
instance.Patch(method, null, new HarmonyMethod(typeof(BanishButton).GetMethod("DrawBanishButton", BindingFlags.Static | BindingFlags.Public)));
Log.Message("banish.animals : RimHUD installed, PostFix_InspectPanePlus_DrawButtons patched", false);
return(true);
}
else
{
Log.Message("banish.animals : RimHUD installed, could not find patch method name", false);
}
}
else
{
Log.Message("banish.animals : RimHUD installed, could not find patch type", false);
}
}
return(false);
}
public static void DoPatches(HarmonyLib.Harmony harm)
{
harm.Patch(AccessTools.Method(typeof(Pawn), "TryGetAttackVerb"),
new HarmonyMethod(typeof(Pawn_TryGetAttackVerb), "Prefix"),
new HarmonyMethod(typeof(Pawn_TryGetAttackVerb), "Postfix"));
AggressiveJobs = new List <JobDef>
{
// Vanilla:
JobDefOf.AttackStatic,
JobDefOf.AttackMelee,
JobDefOf.UseVerbOnThing,
JobDefOf.UseVerbOnThingStatic,
// Misc. Training:
DefDatabase <JobDef> .GetNamedSilentFail("ArcheryShootArrows"),
DefDatabase <JobDef> .GetNamedSilentFail("UseShootingRange"),
DefDatabase <JobDef> .GetNamedSilentFail("UseShootingRange_NonJoy"),
DefDatabase <JobDef> .GetNamedSilentFail("UseMartialArtsTarget"),
DefDatabase <JobDef> .GetNamedSilentFail("UseMartialArtsTarget_NonJoy"),
// Combat Training and Forked Version:
DefDatabase <JobDef> .GetNamedSilentFail("TrainOnCombatDummy"),
// Human Resources:
DefDatabase <JobDef> .GetNamedSilentFail("TrainWeapon"),
DefDatabase <JobDef> .GetNamedSilentFail("PlayAtDummy"),
DefDatabase <JobDef> .GetNamedSilentFail("PlayAtTarget")
}.Where(def => def != null).ToList();
}
static RestrictedStorage()
{
var harmony = new HarmonyLib.Harmony("net.littlewhitemouse.RimWorld.RestrictedStorage");
harmony.PatchAll();
// Add ITab and Comp to proper storage buildings:
// Add to all Building_Storage but not ones in Production (hoppers?)
// This should be slightly faster than xpath xml patching.
var desigProduction = DefDatabase <DesignationCategoryDef> .GetNamed("Production");
var itabResolved = InspectTabManager.GetSharedInstance(typeof(ITab_RestrictedStorage));
foreach (var b in DefDatabase <ThingDef> .AllDefs
.Where(d => (d?.thingClass != null &&
(d.thingClass == typeof(Building_Storage) ||
d.thingClass.IsSubclassOf(typeof(Building_Storage)))))
.Where(d => d.designationCategory != desigProduction))
{
// This should be the equivalent of
// <comps>
// <li>
// <compClass>CompRestrictedStorage</compClass>etc
if (b.comps != null)
{
b.comps.Add(new CompProperties {
compClass = typeof(CompRestrictedStorage)
});
}
else
{
Log.Message("LWM.Restricted Storage: " + b + " does not have comps");
continue;
}
// but....we don't actually want to add this comp to EVERYTHING - I mean, why
// bother? It's not going to be used in the majority of cases. Except...
// the game won't load save-game-data unless the comp is already there. Yes...
// So we do add it to everything.
//
// On the other hand, we DO want to use the ITab for all storage buildings:
// This mirrors ThingDef's resolve references - I didn't want to take the time
// to do a ResolveReferences for every single ThingDef, but if anything
// breaks, that's always an option...
if (b.inspectorTabs != null)
{
b.inspectorTabs.Add(typeof(ITab_RestrictedStorage));
if (b.inspectorTabsResolved != null)
{
b.inspectorTabsResolved.Add(itabResolved);
}
else
{
Log.Message("LWM.Restricted Storage: " + b + " does not have inspectorTabsResolved");
}
}
else
{
Log.Message("LWM.Restricted Storage: " + b + " does not have inspectorTabs");
}
}
}
public Module(ModContentPack content) : base(content)
{
Log.Message("Frontier Developments Shields :: Loading Crash Landing support");
var harmony = new HarmonyLib.Harmony("FrontierDevelopment.Shields.CrashLanding");
harmony.PatchAll(Assembly.GetExecutingAssembly());
Harmony_Projectile.BlacklistType(typeof(CrashPod));
// var baseType = Type.GetType("CrashLanding.CrashPod, CrashLanding");
// var types = baseType.AllSubclassesNonAbstract();
// var blockingTypes = "";
//
// foreach (var current in types)
// {
// blockingTypes += current.Name + " ";
//
// if (current.Name.Contains("_part"))
// {
// harmony.Patch(
// current.GetMethod("Impact", BindingFlags.NonPublic | BindingFlags.Instance),
// new HarmonyMethod(typeof(CrashPodHandler).GetMethod(nameof(CrashPodHandler.CrashPod_Part_Impact_Prefix))));
// }
// else
// {
// harmony.Patch(
// current.GetMethod("Impact", BindingFlags.NonPublic | BindingFlags.Instance),
// new HarmonyMethod(typeof(CrashPodHandler).GetMethod(nameof(CrashPodHandler.CrashPod_Impact_Prefix))));
// }
// }
}
public override void OnApplicationStart()
{
var harmonyinf = new HarmonyLib.Harmony("PhasmophobiaPlayerCount"); // Sadly have to install 0harmony because ML is shit.
harmonyinf.Patch(AccessTools.Method(typeof(LobbyManager), "CreateServer"), new HarmonyMethod(typeof(Main), "CreateServerFix"));
harmonyinf.Patch(AccessTools.Method(typeof(ServerListItem), "SetUI"), new HarmonyMethod(typeof(Main), "UiFix"));
}
public static void ApplyFix()
{
TraceImplType = AppDomain.CurrentDomain.GetAssemblies()
.First(x => x.GetName().Name == "System")
.GetTypes()
.FirstOrDefault(x => x.Name == "TraceImpl");
// assembly that has already fixed this
if (TraceImplType == null)
{
return;
}
ListenersSyncRoot = AccessTools.Property(TraceImplType, "ListenersSyncRoot").GetValue(null, null);
Listeners = (TraceListenerCollection)AccessTools.Property(TraceImplType, "Listeners").GetValue(null, null);
prop_AutoFlush = AccessTools.Property(TraceImplType, "AutoFlush");
HarmonyLib.Harmony instance = new HarmonyLib.Harmony("com.bepis.bepinex.tracefix");
instance.Patch(
typeof(Trace).GetMethod("DoTrace", BindingFlags.Static | BindingFlags.NonPublic),
new HarmonyMethod(typeof(TraceFix).GetMethod(nameof(DoTraceReplacement), BindingFlags.Static | BindingFlags.NonPublic)));
}
public bool IsApplicable(Game game)
{
var patchInfo = Harmony.GetPatchInfo(TargetMethodInfo);
if (AlreadyPatched(patchInfo))
{
return(false);
}
var bytes = TargetMethodInfo.GetCilBytes();
if (bytes == null)
{
return(false);
}
var hash = bytes.GetSha256();
return(hash.SequenceEqual(new byte[] {
0x31, 0x81, 0x47, 0x2b, 0x6a, 0xde, 0xc8, 0x26,
0x37, 0x68, 0xb3, 0x81, 0x0a, 0x47, 0x57, 0x51,
0x37, 0x30, 0xa4, 0xa4, 0xb3, 0xde, 0xa7, 0x59,
0x1a, 0x75, 0x90, 0x8a, 0x18, 0xdf, 0xa7, 0x2b
}));
}
public static void DoHumanoidPatches(HarmonyLib.Harmony harm)
{
harm.Patch(AccessTools.Method(typeof(Pawn_DraftController), "GetGizmos"),
postfix: new HarmonyMethod(typeof(Gizmos), "GetGizmos_Postfix"));
harm.Patch(AccessTools.Method(typeof(PawnAttackGizmoUtility), "GetAttackGizmos"),
postfix: new HarmonyMethod(typeof(Gizmos), "GetAttackGizmos_Postfix"));
}
public static void ApplyCompat(HarmonyLib.Harmony harm)
{
if (ModLister.HasActiveModWithName("RunAndGun") && Base.Features.EnabledAtAll)
{
Log.Message("[MVCF] Applying RunAndGun compatibility patch");
harm.Patch(AccessTools.Method(Type.GetType("RunAndGun.Harmony.Verb_TryCastNextBurstShot, RunAndGun"),
"SetStanceRunAndGun"),
transpiler: new HarmonyMethod(typeof(Compat), "RunAndGunSetStance"));
harm.Patch(AccessTools.Method(Type.GetType("RunAndGun.Harmony.Verb_TryStartCastOn, RunAndGun"),
"Prefix"),
new HarmonyMethod(typeof(Compat), "RunAndGunVerbCast"));
harm.Patch(Type.GetType("RunAndGun.Extensions, RunAndGun")
?.GetMethod("HasRangedWeapon"),
postfix: new HarmonyMethod(typeof(Compat), "RunAndGunHasRangedWeapon"));
}
if (ModLister.HasActiveModWithName("Dual Wield") && Base.Features.HumanoidVerbs)
{
Log.Message("[MVCF] Applying Dual Wield compatibility patch");
GetStancesOffHand = AccessTools.Method(Type.GetType(
"DualWield.Ext_Pawn, DualWield"), "GetStancesOffHand")
.CreateDelegate(typeof(Func <Pawn, Pawn_StanceTracker>));
IsOffHand = AccessTools.Method(Type.GetType(
"DualWield.Ext_ThingWithComps, DualWield"), "IsOffHand")
.CreateDelegate(typeof(Func <ThingWithComps, bool>));
harm.Patch(
Type.GetType("DualWield.Harmony.Pawn_RotationTracker_UpdateRotation, DualWield")
?.GetMethod("Postfix", BindingFlags.NonPublic | BindingFlags.Static),
new HarmonyMethod(typeof(Compat), "UpdateRotation"));
harm.Patch(
Type.GetType("DualWield.Harmony.PawnRenderer_RenderPawnAt, DualWield")
?.GetMethod("Postfix", BindingFlags.NonPublic | BindingFlags.Static),
new HarmonyMethod(typeof(Compat), "RenderPawnAt"));
}
}
public override void OnApplicationStart()
{
FileBasedPrefs.SetInt("PlayersMoney", 999999);
var harmInst = new HarmonyLib.Harmony("PhagmoInfMoney");
harmInst.Patch(AccessTools.Method(typeof(StoreManager), "BuyButton"), postfix: new HarmonyMethod(typeof(Main), "BuyFix"));
harmInst.Patch(AccessTools.Method(typeof(AntiCheatSystem), "CheckPlayerMoney"), new HarmonyMethod(typeof(Main), "IgnoreMethod"));
}
public static void PatchPostfix <TClassToPatch, TMyPatchClass>(this HarmonyLib.Harmony harmonyInstance, string methodToPatch, string myPatchMethod)
{
var classToPatch = typeof(TClassToPatch);
var myPatchClass = typeof(TMyPatchClass);
var methodInfo = classToPatch.GetMethod(methodToPatch);
harmonyInstance.Patch(methodInfo, postfix: new HarmonyMethod(AccessTools.Method(myPatchClass, myPatchMethod)));
}
////
// Postfix patches
////
public static void PatchPostfix <TClassToPatch, TMyPatchClass>(this HarmonyLib.Harmony harmonyInstance, int constructorIndex, string myPatchMethod)
{
var classToPatch = typeof(TClassToPatch);
var myPatchClass = typeof(TMyPatchClass);
var constructor = classToPatch.GetConstructors()[constructorIndex];
harmonyInstance.Patch(constructor, postfix: new HarmonyMethod(AccessTools.Method(myPatchClass, myPatchMethod)));
}
public static void PatchPrefix <TClassToPatch, TMyPatchClass>(this HarmonyLib.Harmony harmonyInstance, string methodToPatch, int methodOverloadIndex, string myPatchMethod)
{
var classToPatch = typeof(TClassToPatch);
var myPatchClass = typeof(TMyPatchClass);
var methodInfo = classToPatch.GetMethods(methodToPatch)[methodOverloadIndex];
harmonyInstance.Patch(methodInfo, prefix: new HarmonyMethod(AccessTools.Method(myPatchClass, myPatchMethod)));
}
public static void Patch(HarmonyObj obj)
{
if (obj.GetPatchedMethods().Any(x => x == coreGame))
{
obj.Unpatch(coreGame, transpiler);
}
obj.Patch(coreGame, null, null, new HarmonyMethod(transpiler));
}
public Module(ModContentPack content) : base(content)
{
Log.Message("Frontier Developments Shields :: Loading Centralized Climate Control (Continued) support");
var harmony = new HarmonyLib.Harmony("FrontierDevelopment.Shields.ClimateControl");
harmony.PatchAll(Assembly.GetExecutingAssembly());
}
// List of assemblies to patch
//public static IEnumerable<string> TargetDLLs => GetDLLs();
//
//public static IEnumerable<string> GetDLLs()
//{
// // Do something before patching Assembly-CSharp.dll
//
// Log("GetDLLs.Assembly-CSharp.dll");
// yield return "Assembly-CSharp.dll";
//
// // Do something after Assembly-CSharp has been patched, and before UnityEngine.dll has been patched
//
// Log("GetDLLs.UnityEngine.dll");
// yield return "UnityEngine.dll";
//
// // Do something after patching is done
//}
// Called before patching occurs
public static void Initialize()
{
Log("Initialize start");
//HarmonyLib.Harmony.CreateAndPatchAll(typeof(Patcher));
//var harmony = new HarmonyLib.Harmony("BepInEx.Lilly.Patcher.Patcher");
instance = HarmonyLib.Harmony.CreateAndPatchAll(typeof(Patcher), "BepInEx.Lilly.Patcher.Patcher");
Log("Initialize end");
}
public Module(ModContentPack content) : base(content)
{
Log.Message("Frontier Developments Shields :: Loading Dubs Bad Hygiene support");
var harmony = new HarmonyLib.Harmony("FrontierDevelopment.Shields.BadHygiene");
harmony.PatchAll(Assembly.GetExecutingAssembly());
}
