using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using Agents;
using BepInEx;
using Enemies;
using GameData;
using Gear;
using Hikaria.Core;
using Hikaria.Core.SNetworkExt;
using Hikaria.DamageAnalyzer.Features;
using Hikaria.DamageAnalyzer.Handlers;
using Hikaria.DamageAnalyzer.Managers;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Collections.Generic;
using Player;
using SNetwork;
using TMPro;
using TheArchive.Core;
using TheArchive.Core.Attributes;
using TheArchive.Core.Attributes.Feature;
using TheArchive.Core.Attributes.Feature.Members;
using TheArchive.Core.Attributes.Feature.Patches;
using TheArchive.Core.Attributes.Feature.Settings;
using TheArchive.Core.FeaturesAPI;
using TheArchive.Core.Localization;
using TheArchive.Core.Models;
using TheArchive.Core.ModulesAPI;
using TheArchive.Interfaces;
using TheArchive.Loader;
using TheArchive.Utilities;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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;
		}
	}
}
namespace Hikaria.DamageAnalyzer
{
	internal static class DebugTypeScanner
	{
		private static readonly string[] Keywords = new string[12]
		{
			"Damage", "Dam_", "EnemyDamage", "EnemyDamageLimb", "BulletWeapon", "BulletHit", "MeleeDamage", "BulletDamage", "SentryGunInstance", "PUI_Watermark",
			"GuiManager", "Watermark"
		};

		private static bool _hasScanned;

		public static void Scan()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			if (_hasScanned)
			{
				return;
			}
			_hasScanned = true;
			try
			{
				string text = Path.Combine(Paths.BepInExRootPath, "interop");
				string text2 = Path.Combine(Paths.BepInExRootPath, "core");
				if (!Directory.Exists(text))
				{
					Logs.LogWarning("DebugTypeScanner skipped: interop folder not found at " + text + ".");
					return;
				}
				Logs.LogInfo("DebugTypeScanner scanning " + text + ".");
				DefaultAssemblyResolver val = new DefaultAssemblyResolver();
				((BaseAssemblyResolver)val).AddSearchDirectory(text);
				((BaseAssemblyResolver)val).AddSearchDirectory(text2);
				ReaderParameters readerParameters = new ReaderParameters
				{
					AssemblyResolver = (IAssemblyResolver)(object)val,
					InMemory = true
				};
				foreach (string item in Directory.EnumerateFiles(text, "*.dll"))
				{
					ScanAssembly(item, readerParameters);
				}
			}
			catch (Exception value)
			{
				Logs.LogError($"DebugTypeScanner failed: {value}");
			}
		}

		private static void ScanAssembly(string assemblyPath, ReaderParameters readerParameters)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			AssemblyDefinition val;
			try
			{
				val = AssemblyDefinition.ReadAssembly(assemblyPath, readerParameters);
			}
			catch (Exception ex)
			{
				Logs.LogWarning("DebugTypeScanner could not read " + Path.GetFileName(assemblyPath) + ": " + ex.Message);
				return;
			}
			AssemblyDefinition val2 = val;
			try
			{
				Enumerator<ModuleDefinition> enumerator = val.Modules.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						foreach (TypeDefinition item in EnumerateTypes((IEnumerable<TypeDefinition>)enumerator.Current.Types))
						{
							bool num = ContainsKeyword(((MemberReference)item).FullName);
							MethodDefinition[] array = ((IEnumerable<MethodDefinition>)item.Methods).Where((MethodDefinition method) => ContainsKeyword(((MemberReference)method).Name)).ToArray();
							if (num || array.Length != 0)
							{
								Logs.LogInfo($"DebugTypeScanner type {((MemberReference)item).FullName} [{Path.GetFileName(assemblyPath)}]");
								MethodDefinition[] array2 = array;
								foreach (MethodDefinition val3 in array2)
								{
									Logs.LogInfo($"DebugTypeScanner method {((MemberReference)item).FullName}.{((MemberReference)val3).Name}({FormatParameters(val3)}) -> {((MemberReference)((MethodReference)val3).ReturnType).FullName}");
								}
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
			}
			finally
			{
				((IDisposable)val2)?.Dispose();
			}
		}

		private static IEnumerable<TypeDefinition> EnumerateTypes(IEnumerable<TypeDefinition> types)
		{
			foreach (TypeDefinition type in types)
			{
				yield return type;
				foreach (TypeDefinition item in EnumerateTypes((IEnumerable<TypeDefinition>)type.NestedTypes))
				{
					yield return item;
				}
			}
		}

		private static bool ContainsKeyword(string value)
		{
			return Keywords.Any((string keyword) => value.Contains(keyword, StringComparison.OrdinalIgnoreCase));
		}

		private static string FormatParameters(MethodDefinition method)
		{
			return string.Join(", ", ((IEnumerable<ParameterDefinition>)((MethodReference)method).Parameters).Select((ParameterDefinition parameter) => ((MemberReference)((ParameterReference)parameter).ParameterType).FullName + " " + ((ParameterReference)parameter).Name));
		}
	}
	[ArchiveDependency(/*Could not decode attribute arguments.*/)]
	[ArchiveModule("Hikaria.DamageAnalyzer", "DamageAnalyzer", "2.0.0")]
	public class EntryPoint : IArchiveModule
	{
		public ILocalizationService LocalizationService { get; set; }

		public IArchiveLogger Logger { get; set; }

		public void Init()
		{
			Logs.Setup(Logger);
		}
	}
	internal static class Logs
	{
		private const string Prefix = "[DamageAnalyzer.Restore]";

		private static IArchiveLogger _logger;

		public static void Setup(IArchiveLogger logger)
		{
			_logger = logger;
		}

		public static void LogDebug(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Debug(Format(data));
			}
		}

		public static void LogError(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Error(Format(data));
			}
		}

		public static void LogInfo(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Info(Format(data));
			}
		}

		public static void LogMessage(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Msg(ConsoleColor.White, Format(data));
			}
		}

		public static void LogWarning(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Warning(Format(data));
			}
		}

		public static void LogNotice(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Notice(Format(data));
			}
		}

		public static void LogSuccess(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Success(Format(data));
			}
		}

		public static void LogException(Exception ex)
		{
			_logger.Exception(ex);
		}

		private static string Format(object data)
		{
			return $"{"[DamageAnalyzer.Restore]"} {data}";
		}
	}
	public static class PluginInfo
	{
		public const string GUID = "Hikaria.DamageAnalyzer";

		public const string NAME = "DamageAnalyzer";

		public const string VERSION = "2.0.0";
	}
}
namespace Hikaria.DamageAnalyzer.Managers
{
	public static class DamageInfoManager
	{
		public struct pDamageInfo
		{
			public pPlayer player;

			public BasicDamageInfo damageInfo;

			public pDamageInfo(SNet_Player player, BasicDamageInfo damageInfo)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				this.player = default(pPlayer);
				((pPlayer)(ref this.player)).SetPlayer(player);
				this.damageInfo = damageInfo;
			}
		}

		public struct BasicDamageInfo
		{
			public pPlayer player;

			public pEnemyAgent enemy;

			public float rawDamage;

			public int limbID;

			public bool allowDirectionalBonus;

			public bool isSleepMulti;

			public float staggerMulti;

			public float precisionMulti;

			public float backstabberMulti;

			public float sleeperMulti;

			public DamageType damageType;

			public DamageSource damageSource;

			public Vector3 position;

			public Vector3 direction;

			public BasicDamageInfo(SNet_Player player, DamageType damageType, DamageSource damageSource, Dam_EnemyDamageLimb limb, Vector3 position, Vector3 direction, float rawDamage, bool allowDirectionalBonus = false, float staggerMulti = 1f, float precisionMulti = 1f, float backstabberMulti = 1f, float sleeperMulti = 1f, bool isSleepMulti = false)
			{
				//IL_0006: 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_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: 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)
				this.player = default(pPlayer);
				((pPlayer)(ref this.player)).SetPlayer(player);
				this.damageType = damageType;
				this.damageSource = damageSource;
				enemy = default(pEnemyAgent);
				((pEnemyAgent)(ref enemy)).Set(limb.m_base.Owner);
				limbID = limb.m_limbID;
				this.position = position;
				this.direction = direction;
				this.rawDamage = rawDamage;
				this.allowDirectionalBonus = allowDirectionalBonus;
				this.staggerMulti = staggerMulti;
				this.precisionMulti = precisionMulti;
				this.backstabberMulti = backstabberMulti;
				this.sleeperMulti = sleeperMulti;
				this.isSleepMulti = isSleepMulti;
			}
		}

		public enum DamageType : byte
		{
			Bullet,
			Melee
		}

		public enum DamageSource : byte
		{
			SentryGun,
			Player
		}

		public static bool ShowSentryDamage = true;

		public static uint LocalAgentGlobalID;

		public static bool IsSleepMulti;

		public static bool IsSentryGunFire;

		public static Dictionary<ulong, float> OriginalBulletDamage = new Dictionary<ulong, float>();

		private static SNetExt_AuthorativeAction<pDamageInfo> m_packet;

		public static void Setup()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			VersionRange compatibleVersions = new VersionRange(new Version(2, 0, 0), new Version(3, 0, 0), true, false);
			m_packet = SNetExt_AuthorativeAction<pDamageInfo>.Create(typeof(pDamageInfo).FullName, (Action<SNet_Player, pDamageInfo>)ReceiveDamageInfo, (Action<pDamageInfo>)null, (Func<SNet_Player, bool>)((SNet_Player p) => CoreAPI.IsPlayerInstalledMod(p, "Hikaria.DamageAnalyzer", compatibleVersions)), (SNet_ChannelType)4);
		}

		public static void SendDamageInfo(BasicDamageInfo damageInfo, SNet_Player player)
		{
			m_packet.Ask(new pDamageInfo(player, damageInfo));
		}

		private static void ReceiveDamageInfo(SNet_Player sender, pDamageInfo data)
		{
			SNet_Player val = default(SNet_Player);
			if (((pPlayer)(ref data.player)).TryGetPlayer(ref val) && val.IsLocal && (Object)(object)sender != (Object)null && sender.IsMaster)
			{
				OriginalBulletDamage[val.Lookup] = data.damageInfo.rawDamage;
				ProcessDamageInfo(data.damageInfo);
			}
		}

		public static void ProcessDamageInfo(BasicDamageInfo damageInfo)
		{
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Invalid comparison between Unknown and I4
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Invalid comparison between Unknown and I4
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)DamageInfoUpdater.Instance == (Object)null)
			{
				Logs.LogWarning("ProcessDamageInfo skipped: DamageInfoUpdater.Instance is null.");
				return;
			}
			SNet_Player player = default(SNet_Player);
			EnemyAgent val = default(EnemyAgent);
			if (!((pPlayer)(ref damageInfo.player)).TryGetPlayer(ref player) || !((pEnemyAgent)(ref damageInfo.enemy)).TryGet(ref val))
			{
				Logs.LogWarning("ProcessDamageInfo skipped: player or enemy lookup failed.");
				return;
			}
			if ((Object)(object)val.Damage == (Object)null || val.Damage.DamageLimbs == null || damageInfo.limbID < 0 || damageInfo.limbID >= ((Il2CppArrayBase<Dam_EnemyDamageLimb>)(object)val.Damage.DamageLimbs).Length)
			{
				Logs.LogWarning($"ProcessDamageInfo skipped: invalid limb index {damageInfo.limbID}.");
				return;
			}
			Dam_EnemyDamageLimb val2 = ((Il2CppArrayBase<Dam_EnemyDamageLimb>)(object)val.Damage.DamageLimbs)[damageInfo.limbID];
			if ((Object)(object)val2 == (Object)null)
			{
				Logs.LogWarning($"ProcessDamageInfo skipped: limb {damageInfo.limbID} is null.");
				return;
			}
			float num = damageInfo.rawDamage;
			bool isCrit = false;
			bool isArmor = false;
			bool isBackMulti = false;
			bool isSleepMulti = damageInfo.isSleepMulti;
			bool isImortal = val.Damage.IsImortal;
			bool allowDirectionalBonus = damageInfo.allowDirectionalBonus;
			float precisionMulti = damageInfo.precisionMulti;
			float sleeperMulti = damageInfo.sleeperMulti;
			float backstabberMulti = damageInfo.backstabberMulti;
			Vector3 direction = damageInfo.direction;
			Vector3 position = damageInfo.position;
			DamageType damageType = damageInfo.damageType;
			DamageSource damageSource = damageInfo.damageSource;
			if ((Object)(object)val2 != (Object)null)
			{
				if ((int)val2.m_type == 1)
				{
					isCrit = true;
				}
				else if ((int)val2.m_type == 2)
				{
					isArmor = true;
				}
			}
			switch (damageType)
			{
			case DamageType.Bullet:
			{
				if (!OriginalBulletDamage.TryGetValue(player.Lookup, out var value))
				{
					Logs.LogWarning($"ProcessDamageInfo skipped: OriginalBulletDamage missing for player {player.Lookup}.");
					return;
				}
				if (damageSource == DamageSource.SentryGun)
				{
					if (!player.IsLocal)
					{
						if (SNet.IsMaster && ((SNetExt_SyncedAction<pDamageInfo>)(object)m_packet).Listeners.Any((SNet_Player p) => p.Lookup == player.Lookup))
						{
							SendDamageInfo(damageInfo, player);
						}
						return;
					}
					if (player.IsLocal && !ShowSentryDamage)
					{
						return;
					}
				}
				num = AgentModifierManager.ApplyModifier((Agent)(object)val, (AgentModifier)7, value);
				break;
			}
			case DamageType.Melee:
				num = AgentModifierManager.ApplyModifier((Agent)(object)val, (AgentModifier)6, num);
				if (isSleepMulti)
				{
					num *= sleeperMulti;
				}
				break;
			}
			num = val2.ApplyWeakspotAndArmorModifiers(num, precisionMulti);
			if (allowDirectionalBonus)
			{
				float num2 = num;
				num = val2.ApplyDamageFromBehindBonus(num, position, direction, backstabberMulti);
				if (num > num2)
				{
					isBackMulti = true;
				}
			}
			if (Hikaria.DamageAnalyzer.Features.DamageAnalyzer.EnableVerboseRestoreLog)
			{
				Logs.LogInfo($"Damage hook triggered: type={damageType}, source={damageSource}, raw={damageInfo.rawDamage:0.00}, real={num:0.00}, limb={damageInfo.limbID}.");
			}
			DamageInfoUpdater.Instance.UpdateBasicDamageInfo(val2, isImortal, isArmor, isCrit, isBackMulti, IsSleepMulti, num);
		}
	}
	internal static class TranslateManager
	{
		public struct EnemyIDName
		{
			public List<uint> IDs;

			public string Name;
		}

		private struct EnemyLimbName
		{
			public string Contain;

			public string Name;
		}

		private static CustomSetting<List<EnemyIDName>> EnemyIDNameSettings = new CustomSetting<List<EnemyIDName>>("EnemyIDNames", new List<EnemyIDName>(), (Action<List<EnemyIDName>>)delegate(List<EnemyIDName> data)
		{
			EnemyID2NameLookup = new Dictionary<uint, string>();
			foreach (EnemyIDName datum in data)
			{
				foreach (uint iD in datum.IDs)
				{
					EnemyID2NameLookup[iD] = datum.Name;
				}
			}
		}, (LoadingTime)1, true);

		private static CustomSetting<List<EnemyLimbName>> EnemyLimbNameSettings = new CustomSetting<List<EnemyLimbName>>("EnemyLimbNames", new List<EnemyLimbName>(), (Action<List<EnemyLimbName>>)delegate(List<EnemyLimbName> data)
		{
			EnemyLimbNamesLookup = data.ToDictionary((EnemyLimbName x) => x.Contain.ToLower(), (EnemyLimbName x) => x.Name);
		}, (LoadingTime)1, true);

		private static Dictionary<string, string> EnemyLimbNamesLookup;

		private static Dictionary<uint, string> EnemyID2NameLookup;

		public static string KILL => Hikaria.DamageAnalyzer.Features.DamageAnalyzer.Localization.GetById(1u, (string)null);

		public static string IMMORTAL => Hikaria.DamageAnalyzer.Features.DamageAnalyzer.Localization.GetById(2u, (string)null);

		public static string UNKNOWN => Hikaria.DamageAnalyzer.Features.DamageAnalyzer.Localization.GetById(3u, (string)null);

		public static string ARMOR => Hikaria.DamageAnalyzer.Features.DamageAnalyzer.Localization.GetById(4u, (string)null);

		public static string CRIT => Hikaria.DamageAnalyzer.Features.DamageAnalyzer.Localization.GetById(5u, (string)null);

		public static string BACKMULTI => Hikaria.DamageAnalyzer.Features.DamageAnalyzer.Localization.GetById(6u, (string)null);

		public static string SLEEPMULTI => Hikaria.DamageAnalyzer.Features.DamageAnalyzer.Localization.GetById(7u, (string)null);

		public static string HITPOSITION_DESC => Hikaria.DamageAnalyzer.Features.DamageAnalyzer.Localization.GetById(8u, (string)null);

		public static string EnemyName(uint id)
		{
			if (!EnemyID2NameLookup.TryGetValue(id, out var value))
			{
				return $"{((GameDataBlockBase<EnemyDataBlock>)(object)GameDataBlockBase<EnemyDataBlock>.GetBlock(id)).name} [{id}]";
			}
			return value;
		}

		public static string EnemyLimb(string LimbName)
		{
			LimbName = LimbName.ToLower();
			if (EnemyLimbNamesLookup.Any(delegate(KeyValuePair<string, string> x)
			{
				if (LimbName.Contains(x.Key))
				{
					LimbName = x.Value;
					return true;
				}
				return false;
			}))
			{
				return LimbName;
			}
			return UNKNOWN;
		}
	}
}
namespace Hikaria.DamageAnalyzer.Handlers
{
	public class DamageInfoUpdater : MonoBehaviour
	{
		private bool Status;

		private float timer;

		private static StringBuilder sb = new StringBuilder(500);

		private Dam_EnemyDamageBase _dmgBase;

		private float _healthMax;

		private float _health;

		private bool _isImmortal;

		private string _limbName = string.Empty;

		private string _enemyName = string.Empty;

		private bool _isKill;

		private bool _isArmor;

		private bool _isCrit;

		private bool _isBackMulti;

		private bool _isSleepMulti;

		private float _damage;

		public static float LastingTime = 2.5f;

		public static int BarFontSize = 12;

		public static int HintFontSize = 12;

		public static int BarLength = 80;

		public static int OffsetX = 970;

		public static int OffsetY = 790;

		public static bool ShowHints = true;

		public static string BarFillChar_Remaining = "#";

		public static string BarFillChar_Lost = "-";

		public static bool ShowHPBar = true;

		public static bool ShowName = true;

		public static bool ShowLimb = true;

		public static bool ShowDamage = true;

		public static Color TextColor = new Color(1f, 1f, 0.8823f, 0.7059f);

		public static TextMeshPro TextMesh;

		public static DamageInfoUpdater Instance { get; private set; }

		public static TextMeshPro WatermarkTextPrefab => GuiManager.WatermarkLayer.m_watermark.m_watermarkText;

		private void Awake()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			Instance = this;
			TextMesh = Object.Instantiate<TextMeshPro>(WatermarkTextPrefab);
			((Transform)((TMP_Text)TextMesh).rectTransform).SetParent(((Transform)((TMP_Text)WatermarkTextPrefab).rectTransform).parent);
			((Transform)((TMP_Text)TextMesh).rectTransform).localPosition = new Vector3((float)OffsetX, (float)OffsetY);
			((TMP_Text)TextMesh).rectTransform.sizeDelta = new Vector2(1920f, ((TMP_Text)TextMesh).rectTransform.sizeDelta.y);
			((Graphic)TextMesh).color = TextColor;
			((TMP_Text)TextMesh).alignment = (TextAlignmentOptions)257;
			((TMP_Text)TextMesh).SetText(string.Empty, true);
			((Transform)((TMP_Text)TextMesh).rectTransform).localScale = Vector3.zero;
		}

		private void FixedUpdate()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (timer >= LastingTime)
			{
				((Transform)((TMP_Text)TextMesh).rectTransform).localScale = Vector3.zero;
				Status = false;
			}
			if (Status)
			{
				timer += Time.fixedDeltaTime;
				UpdateDamageInfo();
			}
		}

		private void RestartTimer()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			timer = 0f;
			Status = true;
			((Transform)((TMP_Text)TextMesh).rectTransform).localScale = Vector3.one;
		}

		public void UpdateBasicDamageInfo(Dam_EnemyDamageLimb dam_EnemyDamageLimb, bool isImmortal, bool isArmor, bool isCrit, bool isBackMulti, bool isSleepMulti, float damage)
		{
			_dmgBase = dam_EnemyDamageLimb.m_base;
			_limbName = TranslateManager.EnemyLimb(((Object)dam_EnemyDamageLimb).name);
			_enemyName = TranslateManager.EnemyName(_dmgBase.Owner.EnemyDataID);
			_isImmortal = isImmortal;
			_isArmor = isArmor;
			_isCrit = isCrit;
			_isBackMulti = isBackMulti;
			_isSleepMulti = isSleepMulti;
			_damage = (isImmortal ? 0f : damage);
			RestartTimer();
		}

		private void UpdateDamageInfo()
		{
			bool flag = (Object)(object)_dmgBase != (Object)null;
			if (flag)
			{
				_health = ((Dam_SyncedDamageBase)_dmgBase).Health;
				_healthMax = ((Dam_SyncedDamageBase)_dmgBase).HealthMax;
			}
			else
			{
				_health = 0f;
			}
			_health = Math.Max(_health, 0f);
			_health = (float)Math.Round(_health, 1);
			if (flag)
			{
				_isKill = !flag || ((Dam_SyncedDamageBase)_dmgBase).Health <= 0f;
			}
			else
			{
				_isKill = true;
			}
			StringBuilder stringBuilder = sb;
			StringBuilder stringBuilder2 = stringBuilder;
			StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(7, 1, stringBuilder);
			handler.AppendLiteral("<size=");
			handler.AppendFormatted(HintFontSize);
			handler.AppendLiteral(">");
			stringBuilder2.Append(ref handler);
			if (ShowName)
			{
				sb.Append(_enemyName);
			}
			if (ShowLimb)
			{
				if (ShowName)
				{
					stringBuilder = sb;
					StringBuilder stringBuilder3 = stringBuilder;
					handler = new StringBuilder.AppendInterpolatedStringHandler(3, 1, stringBuilder);
					handler.AppendLiteral(" (");
					handler.AppendFormatted(_limbName);
					handler.AppendLiteral(")");
					stringBuilder3.Append(ref handler);
				}
				else
				{
					stringBuilder = sb;
					StringBuilder stringBuilder4 = stringBuilder;
					handler = new StringBuilder.AppendInterpolatedStringHandler(2, 2, stringBuilder);
					handler.AppendFormatted(TranslateManager.HITPOSITION_DESC);
					handler.AppendLiteral(": ");
					handler.AppendFormatted(_limbName);
					stringBuilder4.Append(ref handler);
				}
			}
			sb.Append("</size>\n");
			if (ShowHPBar)
			{
				stringBuilder = sb;
				StringBuilder stringBuilder5 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(13, 1, stringBuilder);
				handler.AppendLiteral("<size=");
				handler.AppendFormatted(BarFontSize);
				handler.AppendLiteral(">HP: |-");
				stringBuilder5.Append(ref handler);
				int num = (int)(_health / _healthMax * (float)BarLength);
				if (num == 0 && !_isKill)
				{
					num = 1;
				}
				sb.Append(BarFillChar_Remaining[0], num);
				sb.Append(BarFillChar_Lost[0], BarLength - num);
				sb.Append("-| </size>");
			}
			else
			{
				stringBuilder = sb;
				StringBuilder stringBuilder6 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(18, 1, stringBuilder);
				handler.AppendLiteral("<size=");
				handler.AppendFormatted(BarFontSize);
				handler.AppendLiteral(">HP: </size>");
				stringBuilder6.Append(ref handler);
			}
			stringBuilder = sb;
			StringBuilder stringBuilder7 = stringBuilder;
			handler = new StringBuilder.AppendInterpolatedStringHandler(19, 3, stringBuilder);
			handler.AppendLiteral("<size=");
			handler.AppendFormatted(BarFontSize);
			handler.AppendLiteral(">[");
			handler.AppendFormatted(_health);
			handler.AppendLiteral(" / ");
			handler.AppendFormatted(_healthMax);
			handler.AppendLiteral("]</size>");
			stringBuilder7.AppendLine(ref handler);
			if (ShowHints)
			{
				stringBuilder = sb;
				StringBuilder stringBuilder8 = stringBuilder;
				handler = new StringBuilder.AppendInterpolatedStringHandler(7, 1, stringBuilder);
				handler.AppendLiteral("<size=");
				handler.AppendFormatted(HintFontSize);
				handler.AppendLiteral(">");
				stringBuilder8.Append(ref handler);
				if (ShowDamage)
				{
					stringBuilder = sb;
					StringBuilder stringBuilder9 = stringBuilder;
					handler = new StringBuilder.AppendInterpolatedStringHandler(4, 1, stringBuilder);
					handler.AppendLiteral("HP -");
					handler.AppendFormatted(_damage.ToString("0.00"));
					stringBuilder9.AppendLine(ref handler);
				}
				if (_isCrit)
				{
					sb.AppendLine(TranslateManager.CRIT);
				}
				if (_isBackMulti)
				{
					sb.AppendLine(TranslateManager.BACKMULTI);
				}
				if (_isSleepMulti)
				{
					sb.AppendLine(TranslateManager.SLEEPMULTI);
				}
				if (_isImmortal)
				{
					sb.AppendLine(TranslateManager.IMMORTAL);
				}
				if (_isArmor)
				{
					sb.AppendLine(TranslateManager.ARMOR);
				}
				if (_isKill)
				{
					sb.AppendLine(TranslateManager.KILL);
				}
				sb.Append("</size>");
			}
			((TMP_Text)TextMesh).SetText(sb.ToString(), true);
			sb.Clear();
		}
	}
}
namespace Hikaria.DamageAnalyzer.Features
{
	[DisallowInGameToggle]
	[EnableFeatureByDefault]
	public class DamageAnalyzer : Feature
	{
		public class DamageAnalyzerSetting
		{
			[FSDisplayName("持续时间")]
			public float LastingTime
			{
				get
				{
					return DamageInfoUpdater.LastingTime;
				}
				set
				{
					DamageInfoUpdater.LastingTime = value;
				}
			}

			[FSDisplayName("生命值条文本大小")]
			public int BarFontSize
			{
				get
				{
					return DamageInfoUpdater.BarFontSize;
				}
				set
				{
					DamageInfoUpdater.BarFontSize = value;
				}
			}

			[FSDisplayName("提示文本大小")]
			public int HintFontSize
			{
				get
				{
					return DamageInfoUpdater.HintFontSize;
				}
				set
				{
					DamageInfoUpdater.HintFontSize = value;
				}
			}

			[FSDisplayName("生命值条文本长度")]
			public int BarLength
			{
				get
				{
					return DamageInfoUpdater.BarLength;
				}
				set
				{
					DamageInfoUpdater.BarLength = value;
				}
			}

			[FSDisplayName("显示位置横向偏移量")]
			public int OffsetX
			{
				get
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)DamageInfoUpdater.TextMesh == (Object)null)
					{
						return DamageInfoUpdater.OffsetX;
					}
					return (int)DamageInfoUpdater.TextMesh.transform.localPosition.x;
				}
				set
				{
					//IL_002c: Unknown result type (might be due to invalid IL or missing references)
					DamageInfoUpdater.OffsetX = value;
					if (!((Object)(object)DamageInfoUpdater.TextMesh == (Object)null))
					{
						DamageInfoUpdater.TextMesh.transform.localPosition = new Vector3((float)value, (float)OffsetY, 0f);
					}
				}
			}

			[FSDisplayName("显示位置纵向偏移量")]
			public int OffsetY
			{
				get
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)DamageInfoUpdater.TextMesh == (Object)null)
					{
						return DamageInfoUpdater.OffsetY;
					}
					return (int)DamageInfoUpdater.TextMesh.transform.localPosition.y;
				}
				set
				{
					//IL_002c: Unknown result type (might be due to invalid IL or missing references)
					DamageInfoUpdater.OffsetY = value;
					if (!((Object)(object)DamageInfoUpdater.TextMesh == (Object)null))
					{
						DamageInfoUpdater.TextMesh.transform.localPosition = new Vector3((float)OffsetX, (float)value, 0f);
					}
				}
			}

			[FSDisplayName("显示提示")]
			public bool ShowHints
			{
				get
				{
					return DamageInfoUpdater.ShowHints;
				}
				set
				{
					DamageInfoUpdater.ShowHints = value;
				}
			}

			[FSDisplayName("显示生命值条")]
			public bool ShowHPBar
			{
				get
				{
					return DamageInfoUpdater.ShowHPBar;
				}
				set
				{
					DamageInfoUpdater.ShowHPBar = value;
				}
			}

			[FSDisplayName("显示敌人名称")]
			public bool ShowName
			{
				get
				{
					return DamageInfoUpdater.ShowName;
				}
				set
				{
					DamageInfoUpdater.ShowName = value;
				}
			}

			[FSDisplayName("显示命中部位")]
			public bool ShowLimb
			{
				get
				{
					return DamageInfoUpdater.ShowLimb;
				}
				set
				{
					DamageInfoUpdater.ShowLimb = value;
				}
			}

			[FSDisplayName("显示造成的伤害")]
			public bool ShowDamage
			{
				get
				{
					return DamageInfoUpdater.ShowDamage;
				}
				set
				{
					DamageInfoUpdater.ShowDamage = value;
				}
			}

			[FSDisplayName("显示哨戒炮造成的伤害")]
			[FSDescription("显示哨戒炮的命中信息, 仅当房主也安装了本插件才能显示")]
			public bool ShowSentryDamage
			{
				get
				{
					return DamageInfoManager.ShowSentryDamage;
				}
				set
				{
					DamageInfoManager.ShowSentryDamage = value;
				}
			}

			[FSDisplayName("Enable verbose restore log")]
			public bool EnableVerboseRestoreLog
			{
				get
				{
					return DamageAnalyzer.EnableVerboseRestoreLog;
				}
				set
				{
					DamageAnalyzer.EnableVerboseRestoreLog = value;
				}
			}

			[FSDisplayName("Enable debug scanner")]
			public bool EnableDebugScanner
			{
				get
				{
					return DamageAnalyzer.EnableDebugScanner;
				}
				set
				{
					DamageAnalyzer.EnableDebugScanner = value;
				}
			}

			[FSDisplayName("生命值剩余表示字符")]
			public string BarFillChar_Remaining
			{
				get
				{
					return DamageInfoUpdater.BarFillChar_Remaining;
				}
				set
				{
					DamageInfoUpdater.BarFillChar_Remaining = value;
				}
			}

			[FSDisplayName("生命值失去表示字符")]
			public string BarFillChar_Lost
			{
				get
				{
					return DamageInfoUpdater.BarFillChar_Lost;
				}
				set
				{
					DamageInfoUpdater.BarFillChar_Lost = value;
				}
			}

			[FSDisplayName("文本颜色")]
			public SColor TextColor
			{
				get
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0022: Unknown result type (might be due to invalid IL or missing references)
					//IL_000d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)DamageInfoUpdater.TextMesh == (Object)null)
					{
						return SColorExtensions.ToSColor(DamageInfoUpdater.TextColor);
					}
					return SColorExtensions.ToSColor(((Graphic)DamageInfoUpdater.TextMesh).color);
				}
				set
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_001e: 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)
					DamageInfoUpdater.TextColor = SColorExtensions.ToUnityColor(value);
					if (!((Object)(object)DamageInfoUpdater.TextMesh == (Object)null))
					{
						((Graphic)DamageInfoUpdater.TextMesh).color = SColorExtensions.ToUnityColor(value);
					}
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class PUI_Watermark__UpdateWatermark__Patch
		{
			private static bool IsSetup;

			private static void Postfix()
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				if (!IsSetup)
				{
					GameObject val = new GameObject("DamageAnalyzer");
					val.transform.position = new Vector3((float)Screen.width / 2f, (float)Screen.height / 2f);
					Object.DontDestroyOnLoad((Object)val);
					val.AddComponent<DamageInfoUpdater>();
					IsSetup = true;
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class BulletWeapon__BulletHit__Patch
		{
			private static void Prefix(WeaponHitData weaponRayData, bool doDamage, float additionalDis)
			{
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				if (EnableVerboseRestoreLog)
				{
					Logs.LogInfo("ENTER BulletWeapon.BulletHit");
				}
				SNet_Player owner = weaponRayData.owner.Owner;
				if (!DamageInfoManager.OriginalBulletDamage.TryAdd(owner.Lookup, weaponRayData.damage))
				{
					DamageInfoManager.OriginalBulletDamage[owner.Lookup] = weaponRayData.damage;
				}
				RaycastHit rayHit = weaponRayData.rayHit;
				float num = ((RaycastHit)(ref rayHit)).distance + additionalDis;
				if (num > weaponRayData.damageFalloff.x)
				{
					DamageInfoManager.OriginalBulletDamage[owner.Lookup] *= Mathf.Max(1f - (num - weaponRayData.damageFalloff.x) / (weaponRayData.damageFalloff.y - weaponRayData.damageFalloff.x), BulletWeapon.s_falloffMin);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class Dam_EnemyDamageLimb__MeleeDamage__Patch
		{
			private static void Prefix(Dam_EnemyDamageLimb __instance, float dam, Agent sourceAgent, Vector3 position, Vector3 direction, float staggerMulti = 1f, float precisionMulti = 1f, float backstabberMulti = 1f, float sleeperMulti = 1f)
			{
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Invalid comparison between Unknown and I4
				if (EnableVerboseRestoreLog)
				{
					Logs.LogInfo($"ENTER Dam_EnemyDamageLimb.MeleeDamage Prefix sourceAgent={(Object)(object)sourceAgent != (Object)null} local={DamageInfoManager.LocalAgentGlobalID} source={((sourceAgent != null) ? new ushort?(sourceAgent.GlobalID) : ((ushort?)null))}");
				}
				if (!((Object)(object)sourceAgent == (Object)null) && DamageInfoManager.LocalAgentGlobalID == sourceAgent.GlobalID && !((Il2CppObjectBase)sourceAgent).TryCast<PlayerAgent>().Owner.IsBot && (int)__instance.m_base.Owner.Locomotion.CurrentStateEnum == 14)
				{
					DamageInfoManager.IsSleepMulti = true;
				}
			}

			private static void Postfix(Dam_EnemyDamageLimb __instance, float dam, Agent sourceAgent, Vector3 position, Vector3 direction, float staggerMulti = 1f, float precisionMulti = 1f, float backstabberMulti = 1f, float sleeperMulti = 1f)
			{
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				if (EnableVerboseRestoreLog)
				{
					Logs.LogInfo($"ENTER Dam_EnemyDamageLimb.MeleeDamage Postfix sourceAgent={(Object)(object)sourceAgent != (Object)null} local={DamageInfoManager.LocalAgentGlobalID} source={((sourceAgent != null) ? new ushort?(sourceAgent.GlobalID) : ((ushort?)null))}");
				}
				if (!((Object)(object)sourceAgent == (Object)null) && DamageInfoManager.LocalAgentGlobalID == sourceAgent.GlobalID)
				{
					PlayerAgent val = ((Il2CppObjectBase)sourceAgent).TryCast<PlayerAgent>();
					if (!val.Owner.IsBot)
					{
						DamageInfoManager.ProcessDamageInfo(new DamageInfoManager.BasicDamageInfo(val.Owner, DamageInfoManager.DamageType.Melee, DamageInfoManager.DamageSource.Player, __instance, position, direction, dam, allowDirectionalBonus: true, staggerMulti, precisionMulti, backstabberMulti, sleeperMulti, DamageInfoManager.IsSleepMulti));
						DamageInfoManager.IsSleepMulti = false;
					}
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class Dam_EnemyDamageLimb__BulletDamage__Patch
		{
			private static void Postfix(Dam_EnemyDamageLimb __instance, float dam, Agent sourceAgent, Vector3 position, Vector3 direction, bool allowDirectionalBonus, float staggerMulti = 1f, float precisionMulti = 1f)
			{
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				if (EnableVerboseRestoreLog)
				{
					Logs.LogInfo($"ENTER Dam_EnemyDamageLimb.BulletDamage sourceAgent={(Object)(object)sourceAgent != (Object)null} local={DamageInfoManager.LocalAgentGlobalID} source={((sourceAgent != null) ? new ushort?(sourceAgent.GlobalID) : ((ushort?)null))}");
				}
				if (!((Object)(object)sourceAgent == (Object)null) && (SNet.IsMaster || DamageInfoManager.LocalAgentGlobalID == sourceAgent.GlobalID))
				{
					PlayerAgent val = ((Il2CppObjectBase)sourceAgent).TryCast<PlayerAgent>();
					if (!val.Owner.IsBot)
					{
						DamageInfoManager.ProcessDamageInfo(new DamageInfoManager.BasicDamageInfo(val.Owner, DamageInfoManager.DamageType.Bullet, (!DamageInfoManager.IsSentryGunFire) ? DamageInfoManager.DamageSource.Player : DamageInfoManager.DamageSource.SentryGun, __instance, position, direction, dam, allowDirectionalBonus, staggerMulti, precisionMulti));
					}
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class SentryGunInstance_Firing_Bullets__FireBullet__Patch
		{
			private static void Prefix()
			{
				DamageInfoManager.IsSentryGunFire = true;
			}

			private static void Postfix()
			{
				DamageInfoManager.IsSentryGunFire = false;
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class SentryGunInstance_Firing_Bullets__UpdateFireShotgunSemi__Patch
		{
			private static void Prefix(SentryGunInstance_Firing_Bullets __instance)
			{
				if (Clock.Time > __instance.m_fireBulletTimer)
				{
					DamageInfoManager.IsSentryGunFire = true;
				}
			}

			private static void Postfix()
			{
				DamageInfoManager.IsSentryGunFire = false;
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LocalPlayerAgent__Setup__Patch
		{
			private static void Postfix(LocalPlayerAgent __instance)
			{
				Logs.LogInfo($"LocalPlayerAgent.Setup localGlobalID={((Agent)__instance).GlobalID}");
				DamageInfoManager.LocalAgentGlobalID = ((Agent)__instance).GlobalID;
			}
		}

		public static bool EnableVerboseRestoreLog;

		public static bool EnableDebugScanner;

		public override string Name => "Damage Analyzer";

		public override bool InlineSettingsIntoParentMenu => true;

		public static ILocalizationService Localization { get; set; }

		[FeatureConfig]
		public static DamageAnalyzerSetting Settings { get; set; }

		public override void Init()
		{
			Logs.LogInfo("DamageAnalyzer loaded");
			Logs.LogInfo(EnableDebugScanner ? "DebugTypeScanner enabled" : "DebugTypeScanner disabled");
			if (EnableDebugScanner)
			{
				DebugTypeScanner.Scan();
			}
			ClassInjector.RegisterTypeInIl2Cpp<DamageInfoUpdater>(false);
			DamageInfoManager.Setup();
		}
	}
}