using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("REPO_ShowEnemyHealth")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.3.0")]
[assembly: AssemblyInformationalVersion("1.0.3+1b27dec367654b521dc41d1a2bb4fbcca648c4e7")]
[assembly: AssemblyProduct("ShowEnemyHealth")]
[assembly: AssemblyTitle("REPO_ShowEnemyHealth")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.3.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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ShowEnemyHealth
{
internal static class ConfigManager
{
public static ConfigFile ConfigFile { get; private set; }
public static ConfigEntry<bool> ShowEnemyHealth { get; private set; }
public static ConfigEntry<float> HealthShowTimer { get; private set; }
public static ConfigEntry<float> HealthFontSize { get; private set; }
public static ConfigEntry<string> HealthFontColor { get; private set; }
public static ConfigEntry<bool> ShowEnemyDamage { get; private set; }
public static ConfigEntry<float> DamageFontSize { get; private set; }
public static ConfigEntry<string> DamageFontHighlightColor { get; private set; }
public static ConfigEntry<string> DamageFontColor { get; private set; }
public static ConfigEntry<bool> AttemptMultiplayerHealthSync { get; private set; }
public static void Initialize(ConfigFile configFile)
{
ConfigFile = configFile;
BindConfigs();
}
private static void BindConfigs()
{
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Expected O, but got Unknown
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Expected O, but got Unknown
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Expected O, but got Unknown
//IL_016f: Unknown result type (might be due to invalid IL or missing references)
//IL_0179: Expected O, but got Unknown
//IL_019d: Unknown result type (might be due to invalid IL or missing references)
//IL_01a7: Expected O, but got Unknown
//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
//IL_01d5: Expected O, but got Unknown
AcceptableValueList<string> val = new AcceptableValueList<string>(new string[10] { "black", "blue", "cyan", "green", "grey", "magenta", "orange", "red", "white", "yellow" });
ShowEnemyHealth = ConfigFile.Bind<bool>("General", "ShowEnemyHealth", true, "");
HealthShowTimer = ConfigFile.Bind<float>("General", "HealthShowTimer", 120f, new ConfigDescription("Max seconds to show enemy health", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 600f), Array.Empty<object>()));
HealthFontSize = ConfigFile.Bind<float>("General", "HealthFontSize", 15f, new ConfigDescription("Enemy health font size", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 50f), Array.Empty<object>()));
HealthFontColor = ConfigFile.Bind<string>("General", "HealthFontColor", "grey", new ConfigDescription("Enemy health font color", (AcceptableValueBase)(object)val, Array.Empty<object>()));
ShowEnemyDamage = ConfigFile.Bind<bool>("General", "ShowEnemyDamage", true, "");
DamageFontSize = ConfigFile.Bind<float>("General", "DamageFontSize", 25f, new ConfigDescription("Damage font size", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 50f), Array.Empty<object>()));
DamageFontHighlightColor = ConfigFile.Bind<string>("General", "DamageFontHighlightColor", "red", new ConfigDescription("Damage font highlight color", (AcceptableValueBase)(object)val, Array.Empty<object>()));
DamageFontColor = ConfigFile.Bind<string>("General", "DamageFontColor", "orange", new ConfigDescription("Damage font primary color", (AcceptableValueBase)(object)val, Array.Empty<object>()));
AttemptMultiplayerHealthSync = ConfigFile.Bind<bool>("General", "AttemptMultiplayerHealthSync", true, "Sync enemy health across all clients");
}
}
[RequireComponent(typeof(RectTransform))]
[RequireComponent(typeof(TextMeshProUGUI))]
internal class CustomEnemyHealthUI : WorldSpaceUIChild
{
public static CustomEnemyHealthUI instance;
private Vector3 scale;
internal Vector3 newWorldPosition;
private float showTimer;
private Enemy currEnemy;
private EnemyHealth currEnemyHealth;
private EnemyRigidbody enemyRigidBody;
private TextMeshProUGUI text;
private Vector3 worldspaceOffset;
private Vector3 targetWorldspaceOffset;
public int recalcIntervalFrames = 50;
private int frameCounter;
public float worldspaceOffsetLerpRate = 5f;
public AnimationCurve curveIntro = new AnimationCurve();
public AnimationCurve curveOutro = new AnimationCurve();
private bool hasDied;
internal bool hasExploded;
private void Awake()
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
typeof(WorldSpaceUIChild).GetField("positionOffset", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(this, (object)new Vector3(0f, -0.05f, 0f));
instance = this;
scale = Vector3.one;
text = ((Component)this).GetComponent<TextMeshProUGUI>();
}
public void Show(EnemyHealth enemyHealth, Vector3 screenspaceOffset)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Expected O, but got Unknown
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
//IL_0151: Unknown result type (might be due to invalid IL or missing references)
//IL_015b: Expected O, but got Unknown
//IL_0163: Unknown result type (might be due to invalid IL or missing references)
//IL_0168: Unknown result type (might be due to invalid IL or missing references)
if (!ConfigManager.ShowEnemyHealth.Value)
{
Patches.healthUIElements.Remove(currEnemyHealth);
Object.Destroy((Object)(object)((Component)this).gameObject);
return;
}
((Graphic)text).color = Color.gray;
Color32 val = default(Color32);
if (ColorUtility.DoTryParseHtmlColor(ConfigManager.HealthFontColor.Value, ref val))
{
((Graphic)text).color = Color32.op_Implicit(val);
}
((TMP_Text)text).fontSize = ConfigManager.HealthFontSize.Value;
showTimer = ConfigManager.HealthShowTimer.Value;
if (!Object.op_Implicit((Object)(object)currEnemy) || !Object.op_Implicit((Object)(object)currEnemyHealth))
{
typeof(WorldSpaceUIChild).GetField("positionOffset", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(this, screenspaceOffset);
currEnemyHealth = enemyHealth;
currEnemy = (Enemy)((object)enemyHealth).GetType().GetField("enemy", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(enemyHealth);
newWorldPosition = ((Component)currEnemy).transform.position;
typeof(WorldSpaceUIChild).GetField("worldPosition", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(this, newWorldPosition);
enemyRigidBody = (EnemyRigidbody)((object)currEnemy).GetType().GetField("Rigidbody", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(currEnemy);
UpdateTargetWorldSpaceOffset();
worldspaceOffset = targetWorldspaceOffset;
UpdateTextValues();
}
}
internal void UpdateTargetWorldSpaceOffset()
{
//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_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
Bounds bounds = default(Bounds);
((Bounds)(ref bounds))..ctor(Vector3.zero, Vector3.zero);
Collider[] componentsInChildren = ((Component)enemyRigidBody).GetComponentsInChildren<Collider>();
if (componentsInChildren.Length != 0)
{
bounds = componentsInChildren[0].bounds;
}
Collider[] array = componentsInChildren;
foreach (Collider val in array)
{
if (!val.isTrigger)
{
((Bounds)(ref bounds)).Encapsulate(val.bounds);
}
}
float num = ((Bounds)(ref bounds)).max.y / 2f;
targetWorldspaceOffset = new Vector3(0f, num, 0f);
}
internal void UpdateTextValues()
{
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Invalid comparison between Unknown and I4
if (!((Object)(object)currEnemy == (Object)null) && !((Object)(object)currEnemyHealth == (Object)null))
{
int num = (int)typeof(EnemyHealth).GetField("healthCurrent", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(currEnemyHealth);
int health = currEnemyHealth.health;
((TMP_Text)text).text = $"{num}/{health}";
bool num2 = (bool)typeof(EnemyHealth).GetField("dead", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(currEnemyHealth);
bool flag = (int)currEnemy.CurrentState == 11;
if ((num2 || flag || hasExploded) && !hasDied)
{
Plugin.Logger.LogDebug((object)"Enemy should have died/despawned, clearing healthbar timer");
showTimer = 0.5f;
hasDied = true;
}
}
}
protected override void Update()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
//IL_018e: Unknown result type (might be due to invalid IL or missing references)
//IL_0195: Expected O, but got Unknown
((WorldSpaceUIChild)this).Update();
frameCounter++;
if (frameCounter >= recalcIntervalFrames)
{
frameCounter = 0;
UpdateTargetWorldSpaceOffset();
}
worldspaceOffset = Vector3.Lerp(worldspaceOffset, targetWorldspaceOffset, Time.deltaTime * worldspaceOffsetLerpRate);
FieldInfo? field = typeof(WorldSpaceUIChild).GetField("worldPosition", BindingFlags.Instance | BindingFlags.NonPublic);
_ = (Vector3)field.GetValue(this);
field.SetValue(this, newWorldPosition + worldspaceOffset);
if ((Object)(object)currEnemy != (Object)null)
{
newWorldPosition = currEnemy.CenterTransform.position;
}
if (showTimer > 0f)
{
showTimer -= Time.deltaTime;
float num = 1f;
float num2 = 5f;
float num3 = 20f;
float num4 = Vector3.Distance(((Component)Camera.main).transform.position, newWorldPosition);
Vector3 localScale = scale;
if (num4 > num2)
{
num4 = Mathf.Clamp(num4, num2, num3);
num = 1f - (num4 - num2) / (num3 - num2);
((Vector3)(ref localScale))..ctor(num, num, num);
}
((TMP_Text)text).alpha = num;
((Component)this).transform.localScale = localScale;
UpdateTextValues();
}
else if (showTimer <= 0f && (Object)(object)currEnemyHealth != (Object)null)
{
EnemyParent val = (EnemyParent)((object)currEnemy).GetType().GetField("EnemyParent", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(currEnemy);
Plugin.Logger.LogDebug((object)("Removing enemy health UI for " + val.enemyName + "..."));
Patches.healthUIElements.Remove(currEnemyHealth);
Object.Destroy((Object)(object)((Component)this).gameObject);
}
}
}
[HarmonyPatch]
public static class Patches
{
[CompilerGenerated]
private sealed class <DelayedSetText>d__7 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public FieldInfo fieldInfo;
public object target;
public string targetText;
private TextMeshProUGUI <text>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <DelayedSetText>d__7(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<text>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Expected O, but got Unknown
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
//IL_013a: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<text>5__2 = (TextMeshProUGUI)(fieldInfo?.GetValue(target));
if ((Object)(object)<text>5__2 == (Object)null)
{
<>2__current = null;
<>1__state = 2;
return true;
}
break;
case 2:
<>1__state = -1;
break;
}
((TMP_Text)<text>5__2).text = targetText;
((TMP_Text)<text>5__2).fontSize = ConfigManager.DamageFontSize.Value;
((Graphic)<text>5__2).color = Color.blue;
Color32 val = default(Color32);
if (ColorUtility.DoTryParseHtmlColor(ConfigManager.DamageFontHighlightColor.Value, ref val))
{
((Graphic)<text>5__2).color = Color32.op_Implicit(val);
}
Color32 val2 = default(Color32);
if (ColorUtility.DoTryParseHtmlColor(ConfigManager.DamageFontColor.Value, ref val2))
{
Color val3 = Color32.op_Implicit(val2);
typeof(WorldSpaceUIValueLost).GetField("textColor", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(target, val3);
}
else
{
typeof(WorldSpaceUIValueLost).GetField("textColor", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(target, Color.cyan);
}
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 <DelayedShowHealthUI>d__8 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public CustomEnemyHealthUI healthBar;
public EnemyHealth enemyHealth;
public Vector3 offset;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <DelayedShowHealthUI>d__8(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
try
{
healthBar.Show(enemyHealth, offset);
}
catch (Exception arg)
{
Plugin.Logger.LogDebug((object)$"Handling exception in DelayedShowHealthBar: {arg}");
try
{
healthUIElements.Remove(enemyHealth);
Object.Destroy((Object)(object)healthBar);
}
catch
{
}
}
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();
}
}
internal static readonly Dictionary<EnemyHealth, CustomEnemyHealthUI> healthUIElements = new Dictionary<EnemyHealth, CustomEnemyHealthUI>();
[HarmonyPatch(typeof(EnemyHealth), "Hurt")]
[HarmonyPrefix]
public static void ShowEnemyHealthOnHurt(int _damage, Vector3 _hurtDirection, EnemyHealth __instance)
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Expected O, but got Unknown
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Expected O, but got Unknown
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_013a: Unknown result type (might be due to invalid IL or missing references)
//IL_0171: Unknown result type (might be due to invalid IL or missing references)
//IL_0147: Unknown result type (might be due to invalid IL or missing references)
int num = (int)((object)__instance).GetType().GetField("healthCurrent", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
Enemy val = (Enemy)((object)__instance).GetType().GetField("enemy", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
Vector3 position = val.CenterTransform.position;
int num2 = num - _damage;
if (SemiFunc.IsMasterClientOrSingleplayer())
{
try
{
EnemyParent val2 = (EnemyParent)((object)val).GetType().GetField("EnemyParent", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(val);
_ = (EnemyRigidbody)((object)val).GetType().GetField("Rigidbody", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(val);
bool flag = (bool)typeof(EnemyHealth).GetField("dead", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
Vector3 val3 = default(Vector3);
val3.x = 0f;
val3.y = 0f;
val3.z = 0f;
bool flag2 = num2 <= 0 || flag;
Plugin.Logger.LogDebug((object)$"{val2.enemyName} HURT by {_damage}, currHealth: {num}, will have {num - _damage}, willDie:{flag2} ...");
CreateDamageUI(_damage, position);
if (!flag2)
{
CreateHealthUI(__instance, position);
}
return;
}
catch (Exception arg)
{
Plugin.Logger.LogError((object)$"LogEnemyHurt failed:\n{arg}");
return;
}
}
try
{
CreateDamageUI(_damage, val.CenterTransform.position);
}
catch (Exception arg2)
{
Plugin.Logger.LogError((object)$"FAILED TO ADD UI:\n{arg2}");
}
}
[HarmonyPatch(typeof(EnemyHealth), "HurtRPC")]
[HarmonyPrefix]
public static void ShowEnemyHealthOnHurtRPC(int _damage, Vector3 _hurtDirection, EnemyHealth __instance)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Expected O, but got Unknown
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_017a: Unknown result type (might be due to invalid IL or missing references)
if (SemiFunc.IsMasterClientOrSingleplayer())
{
return;
}
bool flag = false;
int num = Math.Abs(_damage);
if (_damage < 0)
{
flag = true;
}
try
{
Enemy val = (Enemy)((object)__instance).GetType().GetField("enemy", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
EnemyParent val2 = (EnemyParent)((object)val).GetType().GetField("EnemyParent", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(val);
_ = (EnemyRigidbody)((object)val).GetType().GetField("Rigidbody", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(val);
bool flag2 = (bool)typeof(EnemyHealth).GetField("dead", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
Vector3 val3 = default(Vector3);
val3.x = 0f;
val3.y = 0f;
val3.z = 0f;
Vector3 position = val.CenterTransform.position;
FieldInfo field = ((object)__instance).GetType().GetField("healthCurrent", BindingFlags.Instance | BindingFlags.NonPublic);
int num2 = (int)field.GetValue(__instance);
int num3 = num2 - num;
if (ConfigManager.AttemptMultiplayerHealthSync.Value && flag)
{
field.SetValue(__instance, num3);
CreateDamageUI(num, position);
}
bool flag3 = num3 <= 0 || flag2;
Plugin.Logger.LogDebug((object)$"{val2.enemyName} HURT by {num}, currHealth: {num2}, will have {num3}, willDie:{flag3} ...");
if (!flag3)
{
CreateHealthUI(__instance, position);
}
}
catch (Exception arg)
{
Plugin.Logger.LogError((object)$"LogEnemyHurt failed:\n{arg}");
}
}
[HarmonyPatch(typeof(EnemyBang), "ExplodeRPC")]
[HarmonyPostfix]
public static void HandleBangerExplode(EnemyBang __instance)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Expected O, but got Unknown
try
{
Enemy obj = (Enemy)typeof(EnemyBang).GetField("enemy", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
EnemyHealth key = (EnemyHealth)typeof(Enemy).GetField("Health", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
if (healthUIElements.TryGetValue(key, out var value))
{
value.hasExploded = true;
}
}
catch (Exception arg)
{
Plugin.Logger.LogError((object)$"HandleBangerExplode failed:\n{arg}");
}
}
public static void HurtColliderEnemyHurtHook(EnemyHealth enemyHealth, int damage, Vector3 hurtDirection)
{
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
if (SemiFunc.IsNotMasterClient() || !SemiFunc.IsMultiplayer())
{
enemyHealth.Hurt(damage, hurtDirection);
return;
}
try
{
if (ConfigManager.AttemptMultiplayerHealthSync.Value)
{
((PhotonView)typeof(EnemyHealth).GetField("photonView", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(enemyHealth)).RPC("HurtRPC", (RpcTarget)0, new object[2]
{
-damage,
hurtDirection
});
}
}
finally
{
enemyHealth.Hurt(damage, hurtDirection);
}
}
internal static void CreateHealthUI(EnemyHealth enemyHealth, Vector3 enemyPosition)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = default(Vector3);
val.x = 0f;
val.y = 0f;
val.z = 0f;
Vector3 val2 = val;
if (!healthUIElements.ContainsKey(enemyHealth))
{
GameObject obj = Object.Instantiate<GameObject>(WorldSpaceUIParent.instance.TTSPrefab, ((Component)WorldSpaceUIParent.instance).transform.position, ((Component)WorldSpaceUIParent.instance).transform.rotation, ((Component)WorldSpaceUIParent.instance).transform);
Object.Destroy((Object)(object)obj.GetComponent<WorldSpaceUITTS>());
CustomEnemyHealthUI customEnemyHealthUI = obj.AddComponent<CustomEnemyHealthUI>();
typeof(WorldSpaceUIChild).GetField("worldPosition", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(customEnemyHealthUI, enemyPosition);
healthUIElements.Add(enemyHealth, customEnemyHealthUI);
((MonoBehaviour)enemyHealth).StartCoroutine(DelayedShowHealthUI(healthUIElements[enemyHealth], enemyHealth, val2));
}
else
{
healthUIElements[enemyHealth].Show(enemyHealth, val2);
}
}
internal static void CreateDamageUI(int damage, Vector3 worldPosition)
{
//IL_001f: 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_0057: Unknown result type (might be due to invalid IL or missing references)
if (ConfigManager.ShowEnemyDamage.Value)
{
WorldSpaceUIParent instance = WorldSpaceUIParent.instance;
WorldSpaceUIValueLost component = Object.Instantiate<GameObject>(instance.valueLostPrefab, ((Component)instance).transform.position, ((Component)instance).transform.rotation, ((Component)instance).transform).GetComponent<WorldSpaceUIValueLost>();
typeof(WorldSpaceUIValueLost).GetField("worldPosition", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(component, worldPosition);
typeof(WorldSpaceUIValueLost).GetField("value", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(component, damage);
FieldInfo field = typeof(WorldSpaceUIValueLost).GetField("text", BindingFlags.Instance | BindingFlags.NonPublic);
((MonoBehaviour)component).StartCoroutine(DelayedSetText(field, component, $"-{damage}"));
((List<WorldSpaceUIValueLost>)((object)instance).GetType().GetField("valueLostList", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(instance)).Add(component);
}
}
[IteratorStateMachine(typeof(<DelayedSetText>d__7))]
internal static IEnumerator DelayedSetText(FieldInfo fieldInfo, object target, string targetText)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <DelayedSetText>d__7(0)
{
fieldInfo = fieldInfo,
target = target,
targetText = targetText
};
}
[IteratorStateMachine(typeof(<DelayedShowHealthUI>d__8))]
internal static IEnumerator DelayedShowHealthUI(CustomEnemyHealthUI healthBar, EnemyHealth enemyHealth, Vector3 offset)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <DelayedShowHealthUI>d__8(0)
{
healthBar = healthBar,
enemyHealth = enemyHealth,
offset = offset
};
}
}
[HarmonyPatch(typeof(HurtCollider), "EnemyHurt")]
public static class EnemyHurtTranspilerPatch
{
[CompilerGenerated]
private sealed class <Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
{
private int <>1__state;
private CodeInstruction <>2__current;
private int <>l__initialThreadId;
private IEnumerable<CodeInstruction> instructions;
public IEnumerable<CodeInstruction> <>3__instructions;
private MethodInfo <targetHurtMethod>5__2;
private MethodInfo <hookMethod>5__3;
private IEnumerator<CodeInstruction> <>7__wrap3;
CodeInstruction IEnumerator<CodeInstruction>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <Transpiler>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 || (uint)(num - 1) <= 1u)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<targetHurtMethod>5__2 = null;
<hookMethod>5__3 = null;
<>7__wrap3 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Expected O, but got Unknown
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<targetHurtMethod>5__2 = AccessTools.Method(typeof(EnemyHealth), "Hurt", new Type[2]
{
typeof(int),
typeof(Vector3)
}, (Type[])null);
<hookMethod>5__3 = AccessTools.Method(typeof(Patches), "HurtColliderEnemyHurtHook", new Type[3]
{
typeof(EnemyHealth),
typeof(int),
typeof(Vector3)
}, (Type[])null);
<>7__wrap3 = instructions.GetEnumerator();
<>1__state = -3;
break;
case 1:
<>1__state = -3;
break;
case 2:
<>1__state = -3;
break;
}
if (<>7__wrap3.MoveNext())
{
CodeInstruction current = <>7__wrap3.Current;
if (current.opcode == OpCodes.Callvirt && current.operand is MethodInfo methodInfo && methodInfo == <targetHurtMethod>5__2)
{
<>2__current = new CodeInstruction(OpCodes.Call, (object)<hookMethod>5__3);
<>1__state = 1;
return true;
}
<>2__current = current;
<>1__state = 2;
return true;
}
<>m__Finally1();
<>7__wrap3 = null;
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;
if (<>7__wrap3 != null)
{
<>7__wrap3.Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
{
<Transpiler>d__0 <Transpiler>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<Transpiler>d__ = this;
}
else
{
<Transpiler>d__ = new <Transpiler>d__0(0);
}
<Transpiler>d__.instructions = <>3__instructions;
return <Transpiler>d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
}
}
[IteratorStateMachine(typeof(<Transpiler>d__0))]
private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <Transpiler>d__0(-2)
{
<>3__instructions = instructions
};
}
}
[BepInPlugin("REPO_ShowEnemyHealth", "ShowEnemyHealth", "1.0.3")]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Logger;
private Harmony _harmony;
private void Awake()
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
Logger.LogInfo((object)"Plugin ShowEnemyHealth by Rozza is loaded!");
ConfigManager.Initialize(((BaseUnityPlugin)this).Config);
_harmony = new Harmony("EnemyHealth");
PatchAll();
}
private void PatchAll()
{
IEnumerable<Type> enumerable;
try
{
enumerable = Assembly.GetExecutingAssembly().GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
enumerable = ex.Types.Where((Type t) => t != null);
}
foreach (Type item in enumerable)
{
_harmony.PatchAll(item);
}
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "REPO_ShowEnemyHealth";
public const string PLUGIN_NAME = "ShowEnemyHealth";
public const string PLUGIN_VERSION = "1.0.3";
}
}
