using System;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("VoodooNerf")]
[assembly: AssemblyTitle("VoodooNerf")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace VoodooNerf
{
[BepInPlugin("Omniscye.VoodooNerf", "VoodooNerf", "1.0")]
public class VoodooNerf : BaseUnityPlugin
{
internal static VoodooNerf Instance { get; private set; }
internal static ManualLogSource Logger => Instance._logger;
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
internal Harmony? Harmony { get; set; }
private void Awake()
{
Instance = this;
((Component)this).gameObject.transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
Patch();
Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
}
internal void Patch()
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
//IL_0026: Expected O, but got Unknown
if (Harmony == null)
{
Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
Harmony val2 = val;
Harmony = val;
}
Harmony.PatchAll();
}
internal void Unpatch()
{
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
private void Update()
{
}
}
}
namespace Empress.Repo.VoodooKillPatch
{
[BepInPlugin("empress.repo.voodookillpatch", "Voodoo Kill Patch", "1.0.4")]
[BepInProcess("REPO.exe")]
public sealed class Plugin : BaseUnityPlugin
{
public const string PluginGuid = "empress.repo.voodookillpatch";
public const string PluginName = "Voodoo Kill Patch";
public const string PluginVersion = "1.0.4";
internal static ManualLogSource LogSrc;
private Harmony _harmony;
private bool _patched;
internal static Type VoodooType;
private void Awake()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
LogSrc = ((BaseUnityPlugin)this).Logger;
_harmony = new Harmony("empress.repo.voodookillpatch");
TryPatch();
AppDomain.CurrentDomain.AssemblyLoad += OnAssemblyLoad;
}
private void OnDestroy()
{
try
{
AppDomain.CurrentDomain.AssemblyLoad -= OnAssemblyLoad;
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
catch
{
}
}
private void OnAssemblyLoad(object sender, AssemblyLoadEventArgs e)
{
if (_patched)
{
return;
}
try
{
string a = e.LoadedAssembly?.GetName()?.Name;
if (string.Equals(a, "WesleysEnemies", StringComparison.Ordinal))
{
LogSrc.LogInfo((object)"Detected WesleysEnemies assembly load; attempting patch...");
TryPatch();
}
}
catch (Exception arg)
{
LogSrc.LogError((object)$"OnAssemblyLoad handler errored: {arg}");
}
}
private void TryPatch()
{
//IL_0116: Unknown result type (might be due to invalid IL or missing references)
//IL_0124: Expected O, but got Unknown
//IL_0174: Unknown result type (might be due to invalid IL or missing references)
//IL_0181: Expected O, but got Unknown
//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
//IL_01f8: Expected O, but got Unknown
//IL_0235: Unknown result type (might be due to invalid IL or missing references)
//IL_0242: Expected O, but got Unknown
//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
//IL_02f0: Expected O, but got Unknown
//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
//IL_03ce: Expected O, but got Unknown
if (_patched)
{
return;
}
Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(delegate(Assembly a)
{
try
{
return a.GetName().Name.Equals("WesleysEnemies", StringComparison.Ordinal);
}
catch
{
return false;
}
});
if (assembly == null)
{
LogSrc.LogInfo((object)"WesleysEnemies not loaded yet. Waiting...");
return;
}
VoodooType = assembly.GetType("WesleysEnemies.AI.Voodoo", throwOnError: false) ?? assembly.GetType("WesleysEnemies.Voodoo", throwOnError: false) ?? assembly.GetTypes().FirstOrDefault((Type t) => t.Name == "Voodoo");
if (VoodooType == null)
{
LogSrc.LogWarning((object)"Type 'Voodoo' not found in WesleysEnemies; nothing to patch.");
return;
}
MethodInfo method = VoodooType.GetMethod("OnHurt", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (method != null)
{
_harmony.Patch((MethodBase)method, new HarmonyMethod(typeof(Patches).GetMethod("Voodoo_OnHurt_Prefix", BindingFlags.Static | BindingFlags.Public)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
else
{
LogSrc.LogWarning((object)"Method Voodoo.OnHurt() not found; kill-fix may be incomplete.");
}
MethodInfo method2 = VoodooType.GetMethod("OnSpawn", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (method2 != null)
{
_harmony.Patch((MethodBase)method2, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches).GetMethod("Voodoo_OnSpawn_Postfix", BindingFlags.Static | BindingFlags.Public)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
Type typeFromHandle = typeof(EnemyHealth);
MethodInfo method3 = typeFromHandle.GetMethod("Hurt", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
{
typeof(int),
typeof(Vector3)
}, null);
if (method3 != null)
{
_harmony.Patch((MethodBase)method3, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches).GetMethod("EnemyHealth_Hurt_Postfix", BindingFlags.Static | BindingFlags.Public)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
MethodInfo method4 = typeFromHandle.GetMethod("DeathImpulseRPC", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (method4 != null)
{
_harmony.Patch((MethodBase)method4, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches).GetMethod("EnemyHealth_DeathImpulse_Postfix", BindingFlags.Static | BindingFlags.Public)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
Type type = (from a in AppDomain.CurrentDomain.GetAssemblies()
select a.GetType("EnemyRigidbody", throwOnError: false)).FirstOrDefault((Type t) => t != null);
if (type != null)
{
MethodInfo method5 = type.GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (method5 != null)
{
_harmony.Patch((MethodBase)method5, new HarmonyMethod(typeof(Patches).GetMethod("EnemyRigidbody_FixedUpdate_Prefix", BindingFlags.Static | BindingFlags.Public)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
}
Type type2 = (from a in AppDomain.CurrentDomain.GetAssemblies()
select a.GetType("EnemyDirector", throwOnError: false)).FirstOrDefault((Type t) => t != null);
if (type2 != null)
{
MethodInfo method6 = type2.GetMethod("SetInvestigate", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
{
typeof(Vector3),
typeof(float),
typeof(bool)
}, null);
if (method6 != null)
{
_harmony.Patch((MethodBase)method6, new HarmonyMethod(typeof(Patches).GetMethod("EnemyDirector_SetInvestigate_Prefix", BindingFlags.Static | BindingFlags.Public)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
}
_patched = true;
LogSrc.LogInfo((object)"Patched WesleysEnemies.Voodoo.OnHurt() – Voodoo can now be killed normally.");
}
internal static void SafeQuarantine(GameObject go)
{
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
try
{
if ((Object)(object)go == (Object)null)
{
return;
}
Behaviour[] componentsInChildren = go.GetComponentsInChildren<Behaviour>(true);
foreach (Behaviour val in componentsInChildren)
{
try
{
val.enabled = false;
}
catch
{
}
}
Collider[] componentsInChildren2 = go.GetComponentsInChildren<Collider>(true);
foreach (Collider val2 in componentsInChildren2)
{
try
{
val2.enabled = false;
}
catch
{
}
}
Rigidbody[] componentsInChildren3 = go.GetComponentsInChildren<Rigidbody>(true);
foreach (Rigidbody val3 in componentsInChildren3)
{
try
{
val3.isKinematic = true;
val3.velocity = Vector3.zero;
val3.angularVelocity = Vector3.zero;
val3.Sleep();
}
catch
{
}
}
}
catch (Exception ex)
{
ManualLogSource logSrc = LogSrc;
if (logSrc != null)
{
logSrc.LogWarning((object)("SafeQuarantine failed: " + ex.Message));
}
}
}
}
public static class Patches
{
public static bool Voodoo_OnHurt_Prefix(object __instance)
{
return false;
}
public static void Voodoo_OnSpawn_Postfix(object __instance)
{
try
{
object? obj = __instance.GetType().GetField("_enemyHealth", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(__instance);
EnemyHealth val = (EnemyHealth)((obj is EnemyHealth) ? obj : null);
if ((Object)(object)val != (Object)null)
{
if (val.health <= 0)
{
val.health = 100;
}
if (val.healthCurrent <= 0 || val.healthCurrent > val.health)
{
val.healthCurrent = val.health;
}
ManualLogSource logSrc = Plugin.LogSrc;
if (logSrc != null)
{
logSrc.LogInfo((object)$"Voodoo OnSpawn: normalized health to {val.healthCurrent}.");
}
}
}
catch (Exception ex)
{
ManualLogSource logSrc2 = Plugin.LogSrc;
if (logSrc2 != null)
{
logSrc2.LogWarning((object)("Voodoo_OnSpawn_Postfix failed: " + ex.Message));
}
}
}
public static void EnemyHealth_Hurt_Postfix(EnemyHealth __instance, int _damage, Vector3 _hurtDirection)
{
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
try
{
Type voodooType = Plugin.VoodooType;
if (voodooType == null)
{
return;
}
Component component = ((Component)__instance).gameObject.GetComponent(voodooType);
if ((Object)(object)component == (Object)null)
{
return;
}
ManualLogSource logSrc = Plugin.LogSrc;
if (logSrc != null)
{
logSrc.LogInfo((object)$"Voodoo took {_damage} damage. HP now {__instance.healthCurrent}/{__instance.health}.");
}
if (__instance.healthCurrent > 0)
{
return;
}
FieldInfo field = typeof(EnemyHealth).GetField("dead", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
bool flag = false;
if (field != null && field.GetValue(__instance) is bool flag2)
{
flag = flag2;
}
if (!flag)
{
MethodInfo method = typeof(EnemyHealth).GetMethod("Death", BindingFlags.Instance | BindingFlags.NonPublic);
if (method != null)
{
ManualLogSource logSrc2 = Plugin.LogSrc;
if (logSrc2 != null)
{
logSrc2.LogInfo((object)"Voodoo at <=0 HP but not dead. Forcing Death().");
}
method.Invoke(__instance, new object[1] { _hurtDirection });
}
}
Plugin.SafeQuarantine(((Component)__instance).gameObject);
Object.Destroy((Object)(object)((Component)__instance).gameObject, 0.25f);
}
catch (Exception ex)
{
ManualLogSource logSrc3 = Plugin.LogSrc;
if (logSrc3 != null)
{
logSrc3.LogWarning((object)("EnemyHealth_Hurt_Postfix failed: " + ex.Message));
}
}
}
public static void EnemyHealth_DeathImpulse_Postfix(EnemyHealth __instance)
{
try
{
Type voodooType = Plugin.VoodooType;
if (voodooType == null)
{
return;
}
Component component = ((Component)__instance).gameObject.GetComponent(voodooType);
if (!((Object)(object)component == (Object)null))
{
ManualLogSource logSrc = Plugin.LogSrc;
if (logSrc != null)
{
logSrc.LogInfo((object)"Voodoo confirmed dead via DeathImpulse. Destroying GameObject.");
}
Plugin.SafeQuarantine(((Component)__instance).gameObject);
Object.Destroy((Object)(object)((Component)__instance).gameObject);
}
}
catch (Exception ex)
{
ManualLogSource logSrc2 = Plugin.LogSrc;
if (logSrc2 != null)
{
logSrc2.LogWarning((object)("EnemyHealth_DeathImpulse_Postfix failed: " + ex.Message));
}
}
}
public static bool EnemyRigidbody_FixedUpdate_Prefix(object __instance)
{
try
{
Component val = (Component)((__instance is Component) ? __instance : null);
if (val != null)
{
EnemyHealth component = val.GetComponent<EnemyHealth>();
if ((Object)(object)component != (Object)null && component.healthCurrent <= 0)
{
return false;
}
}
}
catch
{
}
return true;
}
public static bool EnemyDirector_SetInvestigate_Prefix(object __instance, Vector3 position, float radius, bool pathfindOnly)
{
try
{
Component val = (Component)((__instance is Component) ? __instance : null);
if (val != null)
{
EnemyHealth componentInParent = val.GetComponentInParent<EnemyHealth>();
if ((Object)(object)componentInParent != (Object)null && componentInParent.healthCurrent <= 0)
{
return false;
}
}
}
catch
{
}
return true;
}
}
}
