using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
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 TMPro;
using UnityEngine;
using UnityEngine.UI;
[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("NoteBoxz")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EnemyIndicators")]
[assembly: AssemblyTitle("EnemyIndicators")]
[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 EnemyIndicators
{
[BepInPlugin("NoteBoxz.EnemyIndicators", "EnemyIndicators", "1.0.0")]
public class EnemyIndicators : BaseUnityPlugin
{
public IndicatorUI UIInstance = null;
public GameObject indicatorSlotPrefab = null;
public GameObject IndicatorHolderPrefab = null;
public Sprite ClockSprite = null;
public Sprite SkullSprite = null;
public Sprite ActiveSprite = null;
public Sprite ZzzSprite = null;
internal static EnemyIndicators Instance { get; private set; }
internal static ManualLogSource Logger => Instance._logger;
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
internal Harmony? Harmony { get; set; }
internal static AssetBundle assetBundle { get; private set; }
public ConfigEntry<bool> ShowRespawnTimers { get; private set; } = null;
private void Awake()
{
Instance = this;
((Component)this).gameObject.transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
Patch();
LoadAssetBundle();
PreInitAssets();
BindConfigs();
Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
}
private void PreInitAssets()
{
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
IndicatorHolderPrefab = assetBundle.LoadAsset<GameObject>("Assets/EnemyIdicatorAssets/InidcatorContainer.prefab");
indicatorSlotPrefab = assetBundle.LoadAsset<GameObject>("Assets/EnemyIdicatorAssets/IndicatorSlot.prefab");
ClockSprite = assetBundle.LoadAsset<Sprite>("Assets/EnemyIdicatorAssets/clock.png");
SkullSprite = assetBundle.LoadAsset<Sprite>("Assets/EnemyIdicatorAssets/skull.png");
ActiveSprite = assetBundle.LoadAsset<Sprite>("Assets/EnemyIdicatorAssets/active.png");
ZzzSprite = assetBundle.LoadAsset<Sprite>("Assets/EnemyIdicatorAssets/zzz.png");
IndicatorUI indicatorUI = IndicatorHolderPrefab.GetComponent<IndicatorUI>();
if ((Object)(object)IndicatorHolderPrefab.GetComponent<IndicatorUI>() == (Object)null)
{
Logger.LogInfo((object)"Adding IndicatorUI component to IndicatorHolderPrefab.");
indicatorUI = IndicatorHolderPrefab.AddComponent<IndicatorUI>();
}
((SemiUI)indicatorUI).showPosition = new Vector2(270f, 0f);
((SemiUI)indicatorUI).hidePosition = new Vector2(900f, 0f);
if ((Object)(object)indicatorSlotPrefab.GetComponent<indicatorSlot>() == (Object)null)
{
Logger.LogInfo((object)"Adding indicatorSlot component to indicatorSlotPrefab.");
indicatorSlotPrefab.AddComponent<indicatorSlot>();
}
}
internal static void LoadAssetBundle()
{
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
if (directoryName == null)
{
throw new InvalidOperationException("Unable to determine assembly location.");
}
string text = Path.Combine(directoryName, "enemyindicatorassets");
assetBundle = AssetBundle.LoadFromFile(text);
if ((Object)(object)assetBundle == (Object)null)
{
throw new InvalidOperationException("Failed to load AssetBundle.");
}
}
private void BindConfigs()
{
ShowRespawnTimers = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Show Respawn Timers", true, "Show respawn timers for enemies.");
}
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()
{
}
}
[HarmonyPatch(typeof(EnemyParent))]
internal static class EnemyParentPatch
{
[HarmonyPrefix]
[HarmonyPatch("Awake")]
private static void Awake_Prefix(EnemyParent __instance)
{
try
{
IndicatorUI.Instance.AddEnemyToIndicator(__instance);
}
catch (Exception arg)
{
EnemyIndicators.Logger.LogError((object)$"Error in EnemyParentPatch.Awake_Prefix: {arg}");
}
}
}
[HarmonyPatch(typeof(HUD))]
internal static class HUDPatch
{
[HarmonyPrefix]
[HarmonyPatch("Awake")]
private static void Awake_Prefix(HUD __instance)
{
try
{
EnemyIndicators.Logger.LogInfo((object)"HUD Awake Prefix called, initializing Enemy Indicators UI...");
if ((Object)(object)EnemyIndicators.Instance.UIInstance == (Object)null)
{
EnemyIndicators.Logger.LogInfo((object)"Instantiating IndicatorUI and assigning it to EnemyIndicators.Instance.UIInstance.");
EnemyIndicators.Instance.UIInstance = Object.Instantiate<GameObject>(EnemyIndicators.Instance.IndicatorHolderPrefab, ((Component)((Component)__instance).transform).transform.Find("HUD Canvas/HUD/Game Hud")).GetComponent<IndicatorUI>();
}
}
catch (Exception arg)
{
EnemyIndicators.Logger.LogError((object)$"Error in HUDPatch.Start_Prefix: {arg}");
}
}
}
[HarmonyPatch(typeof(RoundDirector))]
internal static class RoundDirectorPatch
{
[HarmonyPrefix]
[HarmonyPatch("Start")]
private static void Start_Prefix(RoundDirector __instance)
{
try
{
IndicatorUI.Instance.ClearAllSlots();
}
catch (Exception arg)
{
EnemyIndicators.Logger.LogError((object)$"Error in RoundDirectorPatch.Start_Prefix: {arg}");
}
}
}
public class indicatorSlot : MonoBehaviour
{
public EnemyParent enemyParent = null;
public TMP_Text NameText = null;
public TMP_Text TimerText = null;
public Image StatusImage = null;
public InidcatorStatus status = InidcatorStatus.Active;
private void Awake()
{
TMP_Text[] componentsInChildren = ((Component)this).GetComponentsInChildren<TMP_Text>();
foreach (TMP_Text val in componentsInChildren)
{
if (((Object)val).name == "Text (TMP)")
{
NameText = val;
}
else if (((Object)val).name == "Text (TMP) (1)")
{
TimerText = val;
}
}
StatusImage = ((Component)this).GetComponentInChildren<Image>();
}
private void Update()
{
if ((Object)(object)enemyParent == (Object)null)
{
EnemyIndicators.Logger.LogWarning((object)"EnemyParent is null in indicatorSlot.Update, removing this slot.");
IndicatorUI.Instance.indicatorSlots.Remove(this);
if ((Object)(object)((Component)this).gameObject != (Object)null)
{
Object.Destroy((Object)(object)((Component)this).gameObject);
}
}
else
{
UpdateStatus();
UpdateVisuals();
UpdateTimer();
}
}
private void UpdateStatus()
{
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Invalid comparison between Unknown and I4
if (enemyParent.Enemy.HasHealth && enemyParent.Enemy.Health.dead)
{
status = InidcatorStatus.Dead;
return;
}
if (EnemyDirector.instance.spawnIdlePauseTimer > 0f)
{
status = InidcatorStatus.Waiting;
return;
}
EnemyState currentState = enemyParent.Enemy.CurrentState;
EnemyState val = currentState;
if ((int)val == 11)
{
status = InidcatorStatus.Dipped;
}
else
{
status = InidcatorStatus.Active;
}
}
private void UpdateVisuals()
{
NameText.text = enemyParent.enemyName;
switch (status)
{
case InidcatorStatus.Active:
StatusImage.sprite = EnemyIndicators.Instance.ActiveSprite;
break;
case InidcatorStatus.Waiting:
StatusImage.sprite = EnemyIndicators.Instance.ClockSprite;
break;
case InidcatorStatus.Dipped:
StatusImage.sprite = EnemyIndicators.Instance.ZzzSprite;
break;
case InidcatorStatus.Dead:
StatusImage.sprite = EnemyIndicators.Instance.SkullSprite;
break;
}
}
private void UpdateTimer()
{
if (!EnemyIndicators.Instance.ShowRespawnTimers.Value)
{
((Component)TimerText).gameObject.SetActive(false);
return;
}
switch (status)
{
case InidcatorStatus.Waiting:
((Component)TimerText).gameObject.SetActive(true);
TimerText.text = TimeSpan.FromSeconds(EnemyDirector.instance.spawnIdlePauseTimer).ToString("mm\\:ss");
break;
case InidcatorStatus.Dipped:
case InidcatorStatus.Dead:
((Component)TimerText).gameObject.SetActive(true);
TimerText.text = TimeSpan.FromSeconds(enemyParent.DespawnedTimer).ToString("mm\\:ss");
break;
default:
((Component)TimerText).gameObject.SetActive(false);
break;
}
}
}
public enum InidcatorStatus
{
Active,
Waiting,
Dipped,
Dead
}
public class IndicatorUI : SemiUI
{
public List<indicatorSlot> indicatorSlots = new List<indicatorSlot>();
public static IndicatorUI Instance { get; private set; }
private MapToolController Map => PlayerAvatar.instance.mapToolController;
private void Awake()
{
Instance = this;
}
public override void Start()
{
((SemiUI)this).Start();
((SemiUI)this).Hide();
}
public override void Update()
{
((SemiUI)this).Update();
if (!((Object)(object)Map == (Object)null))
{
if (Map.Active)
{
((SemiUI)this).Show();
}
else
{
((SemiUI)this).Hide();
}
}
}
public void AddEnemyToIndicator(EnemyParent enemyParent)
{
GameObject val = Object.Instantiate<GameObject>(EnemyIndicators.Instance.indicatorSlotPrefab, ((Component)this).transform);
indicatorSlot component = val.GetComponent<indicatorSlot>();
component.enemyParent = enemyParent;
indicatorSlots.Add(component);
base.allChildren.Add(((Component)component).gameObject);
EnemyIndicators.Logger.LogInfo((object)$"Added enemy {enemyParent.enemyName} to indicator slots. Total slots: {indicatorSlots.Count}");
}
public void RemoveEnemyFromIndicator(EnemyParent enemyParent)
{
EnemyParent enemyParent2 = enemyParent;
indicatorSlot indicatorSlot2 = indicatorSlots.Find((indicatorSlot slot) => (Object)(object)slot.enemyParent == (Object)(object)enemyParent2);
if ((Object)(object)indicatorSlot2 != (Object)null)
{
if ((Object)(object)((Component)indicatorSlot2).gameObject != (Object)null)
{
Object.Destroy((Object)(object)((Component)indicatorSlot2).gameObject);
}
indicatorSlots.Remove(indicatorSlot2);
base.allChildren.Remove(((Component)indicatorSlot2).gameObject);
EnemyIndicators.Logger.LogInfo((object)$"Removed enemy {enemyParent2.enemyName} from indicator slots. Remaining slots: {indicatorSlots.Count}");
}
else
{
EnemyIndicators.Logger.LogWarning((object)("Tried to remove enemy " + enemyParent2.enemyName + " from indicators, but it was not found."));
}
}
public void ClearAllSlots()
{
foreach (indicatorSlot indicatorSlot in indicatorSlots)
{
if ((Object)(object)indicatorSlot != (Object)null && (Object)(object)((Component)indicatorSlot).gameObject != (Object)null)
{
Object.Destroy((Object)(object)((Component)indicatorSlot).gameObject);
}
}
indicatorSlots.Clear();
base.allChildren.Clear();
EnemyIndicators.Logger.LogInfo((object)"Cleared all indicator slots.");
}
}
}
