using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
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(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("AbsorptionEitrShield")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("AbsorptionEitrShield")]
[assembly: AssemblyTitle("AbsorptionEitrShield")]
[assembly: AssemblyVersion("1.0.0.0")]
[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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace AbsorptionEitrShield
{
[BepInPlugin("com.absorptioneitrshield.mod", "AbsorptionEitrShield", "0.3.19")]
public sealed class AbsorptionEitrShieldPlugin : BaseUnityPlugin
{
[CompilerGenerated]
private sealed class <InitNetWhenReady>d__16 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public AbsorptionEitrShieldPlugin <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <InitNetWhenReady>d__16(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if ((Object)(object)ZNet.instance == (Object)null || ZRoutedRpc.instance == null)
{
<>2__current = null;
<>1__state = 1;
return true;
}
Net.EnsureRegistered();
if (Net.IsServer())
{
Server_EnableMod = CE_EnableMod.Value;
Server_UseRecharge = CE_UseRecharge.Value;
Net.ServerBroadcastSettings(Server_EnableMod, Server_UseRecharge);
}
else
{
Net.ClientRequestSync();
}
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <RevertClientConfigNextFrame>d__14 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public AbsorptionEitrShieldPlugin <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <RevertClientConfigNextFrame>d__14(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
SetLocalConfigSilently(Server_EnableMod, Server_UseRecharge);
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public const string ModName = "AbsorptionEitrShield";
public const string ModGUID = "com.absorptioneitrshield.mod";
public const string ModVersion = "0.3.19";
internal static ManualLogSource Log;
internal static AbsorptionEitrShieldPlugin Instance;
internal static ConfigEntry<bool> CE_EnableMod;
internal static ConfigEntry<bool> CE_UseRecharge;
internal static bool Server_EnableMod = true;
internal static bool Server_UseRecharge = true;
private static bool _silentConfigSet;
private Harmony _harmony;
private void Awake()
{
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Expected O, but got Unknown
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
CE_EnableMod = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Enable/disable AbsorptionEitrShield. Host/server decides.");
CE_UseRecharge = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "UseRecharge", true, "If enabled: shield works only when Eitr is fully charged; deactivates when Eitr is drained to ~0 and waits for full recharge. Host/server decides.");
((BaseUnityPlugin)this).Config.SettingChanged += OnConfigChanged;
_harmony = new Harmony("com.absorptioneitrshield.mod");
_harmony.PatchAll();
((MonoBehaviour)this).StartCoroutine(InitNetWhenReady());
Log.LogInfo((object)"AbsorptionEitrShield v0.3.19 loaded.");
}
private void OnDestroy()
{
try
{
((BaseUnityPlugin)this).Config.SettingChanged -= OnConfigChanged;
}
catch
{
}
try
{
_harmony.UnpatchSelf();
}
catch
{
}
}
private void OnConfigChanged(object sender, EventArgs e)
{
if (!_silentConfigSet)
{
if (!Net.IsServer())
{
((MonoBehaviour)this).StartCoroutine(RevertClientConfigNextFrame());
return;
}
Server_EnableMod = CE_EnableMod.Value;
Server_UseRecharge = CE_UseRecharge.Value;
Net.ServerBroadcastSettings(Server_EnableMod, Server_UseRecharge);
}
}
[IteratorStateMachine(typeof(<RevertClientConfigNextFrame>d__14))]
private IEnumerator RevertClientConfigNextFrame()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <RevertClientConfigNextFrame>d__14(0)
{
<>4__this = this
};
}
internal static void SetLocalConfigSilently(bool enabled, bool useRecharge)
{
try
{
_silentConfigSet = true;
CE_EnableMod.Value = enabled;
CE_UseRecharge.Value = useRecharge;
}
finally
{
_silentConfigSet = false;
}
}
[IteratorStateMachine(typeof(<InitNetWhenReady>d__16))]
private IEnumerator InitNetWhenReady()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <InitNetWhenReady>d__16(0)
{
<>4__this = this
};
}
}
internal static class Runtime
{
public static float IgnoreAbsorbUntilTime = -1f;
public static bool ModEnabled()
{
return AbsorptionEitrShieldPlugin.Server_EnableMod;
}
public static bool UseRecharge()
{
return AbsorptionEitrShieldPlugin.Server_UseRecharge;
}
public static bool IsDieBypassActive()
{
return Time.time < IgnoreAbsorbUntilTime;
}
}
internal static class Net
{
private const string RPC_RequestSync = "AES_RequestSync";
private const string RPC_SetSettings = "AES_SetSettings";
private static bool _registered;
public static void EnsureRegistered()
{
if (_registered || ZRoutedRpc.instance == null)
{
return;
}
try
{
ZRoutedRpc.instance.Register<ZPackage>("AES_RequestSync", (Action<long, ZPackage>)RPC_RequestSync_Handler);
ZRoutedRpc.instance.Register<ZPackage>("AES_SetSettings", (Action<long, ZPackage>)RPC_SetSettings_Handler);
_registered = true;
}
catch (Exception ex)
{
AbsorptionEitrShieldPlugin.Log.LogWarning((object)("[AES] RPC register failed: " + ex.GetType().Name + ": " + ex.Message));
}
}
public static bool IsServer()
{
try
{
return (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer();
}
catch
{
return false;
}
}
public static void ClientRequestSync()
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Expected O, but got Unknown
try
{
if (ZRoutedRpc.instance == null)
{
return;
}
ZPackage val = new ZPackage();
long num = ZRoutedRpc.Everybody;
try
{
MethodInfo methodInfo = AccessTools.Method(typeof(ZRoutedRpc), "GetServerPeerID", Type.EmptyTypes, (Type[])null);
if (methodInfo != null)
{
object obj = methodInfo.Invoke(ZRoutedRpc.instance, null);
if (obj is long)
{
long num2 = (long)obj;
if (num2 != 0)
{
num = num2;
}
}
}
}
catch
{
}
ZRoutedRpc.instance.InvokeRoutedRPC(num, "AES_RequestSync", new object[1] { val });
}
catch
{
}
}
public static void ServerBroadcastSettings(bool enabled, bool useRecharge)
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
try
{
if (IsServer() && ZRoutedRpc.instance != null)
{
ZPackage val = new ZPackage();
val.Write(enabled);
val.Write(useRecharge);
ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "AES_SetSettings", new object[1] { val });
}
}
catch (Exception ex)
{
AbsorptionEitrShieldPlugin.Log.LogWarning((object)("[AES] Broadcast failed: " + ex.GetType().Name + ": " + ex.Message));
}
}
private static void RPC_RequestSync_Handler(long sender, ZPackage pkg)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Expected O, but got Unknown
if (!IsServer())
{
return;
}
ZPackage val = new ZPackage();
val.Write(AbsorptionEitrShieldPlugin.Server_EnableMod);
val.Write(AbsorptionEitrShieldPlugin.Server_UseRecharge);
try
{
ZRoutedRpc.instance.InvokeRoutedRPC(sender, "AES_SetSettings", new object[1] { val });
}
catch (Exception ex)
{
AbsorptionEitrShieldPlugin.Log.LogWarning((object)("[AES] Reply sync failed: " + ex.GetType().Name + ": " + ex.Message));
}
}
private static void RPC_SetSettings_Handler(long sender, ZPackage pkg)
{
try
{
bool flag = pkg.ReadBool();
bool flag2 = pkg.ReadBool();
AbsorptionEitrShieldPlugin.Server_EnableMod = flag;
AbsorptionEitrShieldPlugin.Server_UseRecharge = flag2;
AbsorptionEitrShieldPlugin.SetLocalConfigSilently(flag, flag2);
AbsorptionEitrShieldPlugin.Log.LogInfo((object)$"[AES] Synced from server: Enabled={flag}, UseRecharge={flag2}");
}
catch (Exception ex)
{
AbsorptionEitrShieldPlugin.Log.LogWarning((object)("[AES] Apply settings failed: " + ex.GetType().Name + ": " + ex.Message));
}
}
}
internal sealed class ShieldState
{
public bool Active;
public float LastMaxEitr;
}
internal static class ShieldSystem
{
private static readonly ConditionalWeakTable<Player, ShieldState> States = new ConditionalWeakTable<Player, ShieldState>();
private const float FullEps = 0.01f;
private const float DrainThreshold = 1.01f;
private static readonly MethodInfo GetMaxEitrMI = AccessTools.Method(typeof(Player), "GetMaxEitr", Type.EmptyTypes, (Type[])null);
public static ShieldState Get(Player p)
{
return States.GetOrCreateValue(p);
}
public static float ReadEitr(Player p)
{
return p.GetEitr();
}
public static float ReadMaxEitr(Player p)
{
try
{
if (GetMaxEitrMI != null)
{
return (float)GetMaxEitrMI.Invoke(p, null);
}
}
catch
{
}
return 0f;
}
public static void Evaluate(Player p)
{
ShieldState shieldState = Get(p);
float num = ReadEitr(p);
float num2 = ReadMaxEitr(p);
if (!Runtime.ModEnabled())
{
shieldState.Active = false;
shieldState.LastMaxEitr = num2;
return;
}
if (!Runtime.UseRecharge())
{
shieldState.Active = num2 > 0.001f;
shieldState.LastMaxEitr = num2;
return;
}
if (num2 <= 0.001f)
{
shieldState.Active = false;
shieldState.LastMaxEitr = 0f;
return;
}
if (shieldState.LastMaxEitr > 0.001f && num2 > shieldState.LastMaxEitr + 0.01f && num < num2 - 0.01f)
{
shieldState.Active = false;
}
shieldState.LastMaxEitr = num2;
if (shieldState.Active)
{
if (num <= 1.01f)
{
shieldState.Active = false;
}
}
else if (num >= num2 - 0.01f)
{
shieldState.Active = true;
}
}
}
internal sealed class ShieldUpdater : MonoBehaviour
{
private Player _player;
private void Awake()
{
_player = ((Component)this).GetComponent<Player>();
}
private void Update()
{
if (!((Object)(object)_player == (Object)null) && ((Character)_player).IsOwner() && !((Character)_player).IsDead())
{
ShieldSystem.Evaluate(_player);
}
}
}
[HarmonyPatch(typeof(Player), "Awake")]
internal static class Player_Awake_AttachUpdater
{
private static void Postfix(Player __instance)
{
if (!((Object)(object)__instance == (Object)null) && ((Character)__instance).IsOwner() && (Object)(object)((Component)__instance).GetComponent<ShieldUpdater>() == (Object)null)
{
((Component)__instance).gameObject.AddComponent<ShieldUpdater>();
}
}
}
internal static class DamageUtil
{
public static float SumHitDamage(HitData hit)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
DamageTypes damage = hit.m_damage;
return damage.m_blunt + damage.m_slash + damage.m_pierce + damage.m_chop + damage.m_pickaxe + damage.m_fire + damage.m_frost + damage.m_lightning + damage.m_poison + damage.m_spirit;
}
public static string F(float v)
{
return v.ToString("0.###", CultureInfo.InvariantCulture);
}
}
[HarmonyPatch]
internal static class Character_ApplyDamage_EitrShieldPatch
{
private struct State
{
public bool Active;
public float Absorb;
public float HpBefore;
public float EitrBefore;
public float D;
}
private static MethodBase TargetMethod()
{
List<MethodInfo> declaredMethods = AccessTools.GetDeclaredMethods(typeof(Character));
foreach (MethodInfo item in declaredMethods)
{
if (!(item == null) && !(item.Name != "ApplyDamage"))
{
ParameterInfo[] parameters = item.GetParameters();
if (parameters.Length >= 1 && !(parameters[0].ParameterType != typeof(HitData)))
{
return item;
}
}
}
return null;
}
private static void Prefix(Character __instance, HitData hit, ref State __state)
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
__state = default(State);
if ((Object)(object)__instance == (Object)null || hit == null || !(__instance is Player))
{
return;
}
Player val = (Player)__instance;
if (!((Character)val).IsOwner() || ((Character)val).IsDead() || Runtime.IsDieBypassActive())
{
return;
}
ShieldSystem.Evaluate(val);
ShieldState shieldState = ShieldSystem.Get(val);
if (!shieldState.Active)
{
return;
}
float eitr = val.GetEitr();
if (eitr <= 0.0001f)
{
return;
}
float num = DamageUtil.SumHitDamage(hit);
if (!(num <= 0.0001f))
{
float num2 = num;
if (num2 > eitr)
{
num2 = eitr;
}
if (!(num2 <= 0.0001f))
{
float health = ((Character)val).GetHealth();
__state.Active = true;
__state.Absorb = num2;
__state.HpBefore = health;
__state.EitrBefore = eitr;
__state.D = num;
((Character)val).SetHealth(health + num2);
((Character)val).AddEitr(0f - num2);
}
}
}
private static Exception Finalizer(Character __instance, HitData hit, State __state, Exception __exception)
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Expected O, but got Unknown
if (__exception != null && __state.Active && (Object)(object)__instance != (Object)null && __instance is Player)
{
try
{
Player val = (Player)__instance;
if (((Character)val).IsOwner() && !((Character)val).IsDead())
{
((Character)val).SetHealth(__state.HpBefore);
((Character)val).AddEitr(__state.Absorb);
}
}
catch
{
}
}
return __exception;
}
}
[HarmonyPatch]
internal static class Terminal_DieBypassPatch
{
[CompilerGenerated]
private sealed class <TargetMethods>d__0 : IEnumerable<MethodBase>, IEnumerable, IEnumerator<MethodBase>, IDisposable, IEnumerator
{
private int <>1__state;
private MethodBase <>2__current;
private int <>l__initialThreadId;
private Type <t>5__1;
private List<MethodInfo>.Enumerator <>s__2;
private MethodInfo <m>5__3;
private ParameterInfo[] <p>5__4;
MethodBase IEnumerator<MethodBase>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <TargetMethods>d__0(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 1)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<t>5__1 = null;
<>s__2 = default(List<MethodInfo>.Enumerator);
<m>5__3 = null;
<p>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<t>5__1 = typeof(Terminal);
<>s__2 = AccessTools.GetDeclaredMethods(<t>5__1).GetEnumerator();
<>1__state = -3;
break;
case 1:
<>1__state = -3;
<p>5__4 = null;
<m>5__3 = null;
break;
}
while (<>s__2.MoveNext())
{
<m>5__3 = <>s__2.Current;
if (!(<m>5__3 == null) && (<m>5__3.Name.Contains("RunCommand") || <m>5__3.Name.Contains("TryRunCommand")))
{
<p>5__4 = <m>5__3.GetParameters();
if (<p>5__4.Length >= 1 && !(<p>5__4[0].ParameterType != typeof(string)))
{
<>2__current = <m>5__3;
<>1__state = 1;
return true;
}
}
}
<>m__Finally1();
<>s__2 = default(List<MethodInfo>.Enumerator);
return false;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
((IDisposable)<>s__2).Dispose();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<MethodBase> IEnumerable<MethodBase>.GetEnumerator()
{
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
return this;
}
return new <TargetMethods>d__0(0);
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<MethodBase>)this).GetEnumerator();
}
}
[IteratorStateMachine(typeof(<TargetMethods>d__0))]
private static IEnumerable<MethodBase> TargetMethods()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <TargetMethods>d__0(-2);
}
private static void Prefix(object[] __args)
{
if (__args == null || __args.Length < 1)
{
return;
}
string text = __args[0] as string;
if (!string.IsNullOrEmpty(text))
{
string text2 = text.Trim();
if (text2.StartsWith("/"))
{
text2 = text2.Substring(1).Trim();
}
if (text2.Equals("die", StringComparison.OrdinalIgnoreCase) || text2.StartsWith("die ", StringComparison.OrdinalIgnoreCase))
{
Runtime.IgnoreAbsorbUntilTime = Time.time + 0.35f;
}
}
}
}
}
