/// <summary>Unpatches patches of a given type and/or Harmony ID</summary>
/// <param name="type">The patch type</param>
/// <param name="harmonyID">Harmony ID or (*) for any</param>
///
public PatchProcessor Unpatch(HarmonyPatchType type, string harmonyID)
{
foreach (var original in originals)
{
var patchInfo = original.ToPatchInfo();
lock (patchInfo)
{
if (type == HarmonyPatchType.All || type == HarmonyPatchType.Prefix)
{
patchInfo.RemovePrefix(harmonyID);
}
if (type == HarmonyPatchType.All || type == HarmonyPatchType.Postfix)
{
patchInfo.RemovePostfix(harmonyID);
}
if (type == HarmonyPatchType.All || type == HarmonyPatchType.Transpiler)
{
patchInfo.RemoveTranspiler(harmonyID);
}
if (type == HarmonyPatchType.All || type == HarmonyPatchType.Finalizer)
{
patchInfo.RemoveFinalizer(harmonyID);
}
}
original.GetMethodPatcher().Apply();
}
return(this);
}
public void Remove(Harmony harmony, HarmonyPatchType patchType = HarmonyPatchType.All)
{
harmony.Unpatch(
original: Original,
type: patchType,
harmonyID: harmony.Id
);
}
/// <summary>Unpatches a method</summary>
/// <param name="original">The original method</param>
/// <param name="type">The patch type</param>
/// <param name="harmonyID">The optional Harmony ID to restrict unpatching to a specific instance</param>
///
public void Unpatch(MethodBase original, HarmonyPatchType type, string harmonyID = null)
{
var processor = new PatchProcessor(this, new List <MethodBase> {
original
});
processor.Unpatch(type, harmonyID);
}
public PatchTemplate(HarmonyPatchType type, MethodInfo original, string patch = null, HarmonyMethod method = null)
{
this.type = type;
this.original = original;
this.patch = patch ?? method.methodName;
this.method = method ?? new HarmonyMethod(
methodType: typeof(HarmonyPatches),
methodName: patch);
}
protected Patch(HarmonyPatchType type,
Reflect.Method patchMethod,
Reflect.Method targetMethod,
int priority)
{
_type = type;
_patchMethod = patchMethod;
_targetMethod = targetMethod;
_priority = priority;
}
public void Remove(Harmony harmony, HarmonyPatchType patchType = HarmonyPatchType.All)
{
foreach (var originalMethod in Original)
{
harmony.Unpatch(
original: originalMethod,
type: patchType,
harmonyID: harmony.Id
);
}
}
/// <summary>
/// Checks to see if a patch with the specified method name (the method used in the
/// patch class) and type is defined.
/// </summary>
/// <param name="instance">The Harmony instance to query for patches. Unused.</param>
/// <param name="target">The target method to search for patches.</param>
/// <param name="type">The patch type to look up.</param>
/// <param name="name">The patch method name to look up (name as declared by patch owner).</param>
/// <returns>true if such a patch was found, or false otherwise</returns>
public static bool HasPatchWithMethodName(Harmony instance, MethodBase target,
HarmonyPatchType type, string name)
{
bool found = false;
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException(nameof(name));
}
var patches = Harmony.GetPatchInfo(target);
if (patches != null)
{
ICollection <Patch> patchList;
switch (type)
{
case HarmonyPatchType.Prefix:
patchList = patches.Prefixes;
break;
case HarmonyPatchType.Postfix:
patchList = patches.Postfixes;
break;
case HarmonyPatchType.Transpiler:
patchList = patches.Transpilers;
break;
case HarmonyPatchType.All:
default:
// All
if (patches.Transpilers != null)
{
found = HasPatchWithMethodName(patches.Transpilers, name);
}
if (patches.Prefixes != null)
{
found = found || HasPatchWithMethodName(patches.Prefixes, name);
}
patchList = patches.Postfixes;
break;
}
if (patchList != null)
{
found = found || HasPatchWithMethodName(patchList, name);
}
}
return(found);
}
public static bool PatchProcessor_Unpatch2_Prefix(HarmonyPatchType type, string harmonyID, object ___instance, List <MethodBase> ___originals)
{
var harmony = CreateHarmony(___instance);
foreach (var method in ___originals)
{
#if DEBUG
UnityEngine.Debug.Log($"Unpatching patch ({type}) from method {method.FullDescription()} (HarmonyId: {harmony.Id})");
#endif
harmony.Unpatch(method, type, harmonyID);
}
return(false);
}
private static void ApplyPatch(MethodInfo target, HarmonyPatchType patchType, MethodInfo patch)
{
var harmonyMethod = new HarmonyMethod(patch);
switch (patchType)
{
case HarmonyPatchType.Prefix:
NVHarmonyPatcher.NVHarmony.Patch(target, harmonyMethod);
break;
case HarmonyPatchType.Postfix:
NVHarmonyPatcher.NVHarmony.Patch(target, postfix: harmonyMethod);
break;
case HarmonyPatchType.Transpiler:
NVHarmonyPatcher.NVHarmony.Patch(target, transpiler: harmonyMethod);
break;
}
}
public static void ApplyHarmonyPatches(string id)
{
Harmony harmony = new(id : id);
foreach (Patch patch in Patches)
{
Log.D($"Applying Harmony patch {patch.TargetType}{PatchDelimiter}{patch.PatchMethod}",
CustomCommunityCentre.ModEntry.Config.DebugMode);
// Generate patch method
string harmonyTypeName = patch.PatchMethod.Split(PatchDelimiter).Last();
HarmonyPatchType harmonyType = (HarmonyPatchType)Enum.Parse(
enumType: typeof(HarmonyPatchType),
value: harmonyTypeName);
HarmonyMethod harmonyMethod = new(
methodType : patch.PatchType,
methodName : patch.PatchMethod);
// Get original method
System.Reflection.MethodBase original = (patch.TargetMethod == ConstructorName)
? (System.Reflection.MethodBase)AccessTools.Constructor(
type: patch.TargetType,
parameters: patch.TargetParams)
: AccessTools.Method(
type: patch.TargetType,
name: patch.TargetMethod,
parameters: patch.TargetParams);
// Apply patch to original
harmony.Patch(
original: original,
prefix: harmonyType == HarmonyPatchType.Prefix ? harmonyMethod : null,
postfix: harmonyType == HarmonyPatchType.Postfix ? harmonyMethod : null,
transpiler: harmonyType == HarmonyPatchType.Transpiler ? harmonyMethod : null,
finalizer: harmonyType == HarmonyPatchType.Finalizer ? harmonyMethod : null);
}
}
public void Apply()
{
if (Applied)
{
return;
}
foreach (PatchMethodInfo patchMethodInfo in this.GetPatchMethodsInfo())
{
MethodInfo patchMethod = patchMethodInfo.PatchMethod;
MethodInfo patchedMethod = patchMethodInfo.PatchedMethod;
HarmonyPatchType harmonyPatchType = patchMethodInfo.HarmonyPatchType;
HarmonyMethod harmonyMethod = new HarmonyMethod(patchMethod);
switch (harmonyPatchType)
{
case HarmonyPatchType.Prefix:
_harmony.Patch(patchedMethod, prefix: harmonyMethod);
break;
case HarmonyPatchType.Postfix:
_harmony.Patch(patchedMethod, postfix: harmonyMethod);
break;
case HarmonyPatchType.Transpiler:
_harmony.Patch(patchedMethod, transpiler: harmonyMethod);
break;
case HarmonyPatchType.Finalizer:
_harmony.Patch(patchedMethod, finalizer: harmonyMethod);
break;
default:
throw new NotSupportedException($"{harmonyPatchType} action is not supported when manually patching");
}
}
Applied = true;
}
public void Remove(HarmonyInstance harmony, HarmonyPatchType patchType = HarmonyPatchType.All)
{
harmony.Unpatch(Original, patchType, harmony.Id);
}
public static void Unpatch(this MethodInfo method, HarmonyPatchType patchType = HarmonyPatchType.All, string id = null)
{
Harmony.Unpatch(method, patchType, id);
}
public HarmonyPatch(MethodInfo patch, HarmonyPatchType type, string id, int index, int priority = -1)
{
this.patch = patch; this.type = type; this.id = id; this.index = index; this.priority = priority;
}
/// <summary>Unpatches a method by patching it with zero patches. Fully unpatching is not supported. Be careful, unpatching is global</summary>
/// <param name="original">The original method/constructor</param>
/// <param name="type">The <see cref="HarmonyPatchType"/></param>
/// <param name="harmonyID">The optional Harmony ID to restrict unpatching to a specific Harmony instance</param>
///
public void Unpatch(MethodBase original, HarmonyPatchType type, string harmonyID = null)
{
var processor = CreateProcessor(original);
_ = processor.Unpatch(type, harmonyID);
}
public PatchMethodInfo(MethodInfo patchedMethod, HarmonyPatchType harmonyPatchType, MethodInfo patchMethod)
{
PatchedMethod = patchedMethod;
HarmonyPatchType = harmonyPatchType;
PatchMethod = patchMethod;
}
public void Unpatch(MethodBase original, HarmonyPatchType type, string harmonyId = null) => _harmonyInstance.Unpatch(original, type, harmonyId);
