using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BattleImprove;
using BattleImprove.Components;
using BattleImprove.Patcher.BattleFeedback;
using BattleImprove.Patcher.QOL;
using BattleImprove.Patcher.TakeHitPatcher;
using BattleImprove.UI.InGame;
using BattleImprove.Utils;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PerfectRandom.Sulfur.Core;
using PerfectRandom.Sulfur.Core.DevTools;
using PerfectRandom.Sulfur.Core.Input;
using PerfectRandom.Sulfur.Core.Items;
using PerfectRandom.Sulfur.Core.Stats;
using PerfectRandom.Sulfur.Core.Units;
using PerfectRandom.Sulfur.Core.Weapons;
using PerfectRandom.Sulfur.Core.World;
using TMPro;
using UnityEngine;
using UnityEngine.Rendering.Universal;
using UnityEngine.UI;
using UrGUI.UWindow;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Cmmmmmm")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("GPL-3.0 license")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyInformationalVersion("1.2.0")]
[assembly: AssemblyProduct("Battle Improvements")]
[assembly: AssemblyTitle("BattleImprove")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/CmmmmmmLau/SulFur_Battle_improvement")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class DamageInfo : MonoBehaviour
{
	public TMP_Text tmpTotalDamage;

	public GameObject damageSourcePrefab;

	private int currentDamage;

	private GameObject damageParent;

	private GameObject firstMessage;

	private GameObject messageContainer;

	private float timer;

	private int totalDamage;

	private void Start()
	{
		damageParent = ((Component)((Component)this).gameObject.transform.Find("Total")).gameObject;
		damageParent.SetActive(false);
		totalDamage = 0;
		currentDamage = 0;
		timer = 10f;
		messageContainer = ((Component)((Component)this).gameObject.transform.Find("Detail")).gameObject;
	}

	private void Update()
	{
		UpdateDamage();
		timer += Time.deltaTime;
		if (timer > 5f)
		{
			damageParent.SetActive(false);
			timer = 0f;
			totalDamage = 0;
			currentDamage = 0;
		}
	}

	public void ShowDamageInfo(string type, int damage)
	{
		AddTotalDamage(damage);
		AddDamageSource(type, damage);
	}

	private void AddTotalDamage(int damage)
	{
		damageParent.SetActive(true);
		totalDamage += damage;
	}

	private void AddDamageSource(string type, int damage)
	{
		if ((Object)(object)firstMessage != (Object)null && (Object)(object)messageContainer != (Object)null)
		{
			DamageSource[] componentsInChildren = messageContainer.GetComponentsInChildren<DamageSource>();
			foreach (DamageSource damageSource in componentsInChildren)
			{
				if (damageSource.damageType == type)
				{
					damageSource.damage += damage;
					damageSource.Reset();
					return;
				}
			}
		}
		firstMessage = Object.Instantiate<GameObject>(damageSourcePrefab, messageContainer.transform);
		firstMessage.transform.SetAsFirstSibling();
		firstMessage.GetComponent<DamageSource>().InitMessage(type, damage);
	}

	private void UpdateDamage()
	{
		if (currentDamage < totalDamage)
		{
			timer = 0f;
			int num = Mathf.Max(1, (totalDamage - currentDamage) / 100);
			currentDamage += num;
			tmpTotalDamage.text = currentDamage.ToString();
		}
	}
}
public class DamageSource : MonoBehaviour
{
	public string damageType;

	public int damage;

	public TMP_Text message;

	private float timer;

	public void Reset()
	{
		timer = 0f;
		message.text = damageType + " " + damage;
	}

	private void Start()
	{
		timer = 0f;
		message = ((Component)this).GetComponent<TMP_Text>();
	}

	private void Update()
	{
		timer += Time.deltaTime;
		if (timer > 5f)
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}

	public void InitMessage(string type, int damage)
	{
		damageType = type;
		this.damage = damage;
		message.text = damageType + " " + damage;
		Reset();
	}
}
public class HitSoundEffect : MonoBehaviour
{
	public AudioClip[] hitClose;

	public AudioClip[] hitFar;

	public AudioClip[] hitCrit;

	public void PlayHitSound(Vector3 position, bool isCrit, bool isFar = false, float volume = 1f)
	{
		//IL_0018: 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_0039: Unknown result type (might be due to invalid IL or missing references)
		if (isCrit)
		{
			AudioSource.PlayClipAtPoint(hitCrit[Random.Range(0, hitCrit.Length)], position, volume);
		}
		else if (isFar)
		{
			AudioSource.PlayClipAtPoint(hitFar[Random.Range(0, hitFar.Length)], position, volume);
		}
		else
		{
			AudioSource.PlayClipAtPoint(hitClose[Random.Range(0, hitClose.Length)], position, volume);
		}
	}
}
public class KillMessage : MonoBehaviour
{
	private struct KillMessageStruct
	{
		public string EnemyName;

		public string WeaponName;

		public string Exp;
	}

	public TMP_Text tmpEnemyName;

	public TMP_Text tmpWeaponName;

	public TMP_Text tmpExp;

	public AudioClip killSound;

	public AudioClip headShotKillSound;

	public AudioSource audioSource;

	public Animator killMessageAnim;

	private readonly Queue<KillMessageStruct> messageQueue = new Queue<KillMessageStruct>();

	private bool isShowing;

	private PluginData.AttackFeedback data;

	private void Start()
	{
		isShowing = false;
	}

	private void Update()
	{
		if (messageQueue.Count != 0 && !isShowing)
		{
			ShowKIllMessage();
		}
	}

	public void AddKillMessage(string enemyName, string weaponName, string exp)
	{
		messageQueue.Enqueue(new KillMessageStruct
		{
			EnemyName = enemyName,
			WeaponName = weaponName,
			Exp = exp
		});
	}

	private void ShowKIllMessage()
	{
		KillMessageStruct killMessageStruct = messageQueue.Dequeue();
		tmpEnemyName.text = killMessageStruct.EnemyName;
		tmpWeaponName.text = killMessageStruct.WeaponName;
		tmpExp.text = killMessageStruct.Exp;
		((MonoBehaviour)this).StartCoroutine(Showing());
	}

	private IEnumerator Showing()
	{
		isShowing = true;
		killMessageAnim.SetTrigger("Pop");
		yield return (object)new WaitForEndOfFrame();
		Transform transform = ((Component)this).transform;
		LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((transform is RectTransform) ? transform : null));
		yield return (object)((messageQueue.Count > 1) ? new WaitForSeconds(0.8f) : new WaitForSeconds(1.5f));
		killMessageAnim.SetTrigger("Fade");
		yield return (object)new WaitForSeconds(0.3f);
		isShowing = false;
	}

	public void OnEnemyKill(bool isHeadShot)
	{
		if (data == null)
		{
			data = PluginData.DataDict["AttackFeedback"] as PluginData.AttackFeedback;
		}
		audioSource.PlayOneShot(isHeadShot ? headShotKillSound : killSound, data.messageVolume);
	}
}
public class xCrossHair : MonoBehaviour
{
	public Animator crossHairAnim;

	private PluginData.AttackFeedback data;

	private Image[] images;

	private void Start()
	{
		if (data == null)
		{
			data = PluginData.DataDict["AttackFeedback"] as PluginData.AttackFeedback;
		}
		images = ((Component)this).GetComponentsInChildren<Image>();
	}

	public void StartTrigger(string type)
	{
		if (!(type == "Hit"))
		{
			if (type == "Kill")
			{
				KillTrigger();
			}
		}
		else
		{
			HitTrigger();
		}
	}

	private void HitTrigger()
	{
		crossHairAnim.SetTrigger("Hit");
		SetHitColor();
	}

	private void KillTrigger()
	{
		crossHairAnim.SetTrigger("Kill");
		SetKillColor();
	}

	private void SetHitColor()
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		Image[] array = images;
		for (int i = 0; i < array.Length; i++)
		{
			((Graphic)array[i]).color = data.hitColor;
		}
	}

	private void SetKillColor()
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		Image[] array = images;
		for (int i = 0; i < array.Length; i++)
		{
			((Graphic)array[i]).color = data.killColor;
		}
	}
}
public class LootDropVFX : MonoBehaviour
{
	public ParticleSystem[] systems;

	private GameObject parentObject;

	private bool isScaling;

	private void Start()
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.localPosition = new Vector3(0f, 0.1f, 0f);
		isScaling = true;
		((MonoBehaviour)this).StartCoroutine(StopScale());
	}

	private void Update()
	{
		//IL_004c: 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_0074: 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_008b: 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_009e: Unknown result type (might be due to invalid IL or missing references)
		bool mouseButton = Input.GetMouseButton(1);
		ParticleSystem[] array = systems;
		for (int i = 0; i < array.Length; i++)
		{
			((Component)array[i]).gameObject.SetActive(!mouseButton);
		}
		if (isScaling)
		{
			((Component)this).gameObject.transform.localScale = parentObject.transform.localScale;
			array = systems;
			foreach (ParticleSystem obj in array)
			{
				Vector3 localScale = parentObject.transform.localScale;
				((Component)obj).transform.localScale = new Vector3(1f / localScale.x, 1f / localScale.y, 1f / localScale.z);
			}
		}
	}

	private IEnumerator StopScale()
	{
		yield return (object)new WaitForSeconds(3f);
		isScaling = false;
	}

	public void SetParent(GameObject parent)
	{
		parentObject = parent;
	}
}
namespace BattleImprove
{
	[BepInPlugin("BattleImprove", "Battle Improvements", "1.2.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		internal static Plugin instance;

		internal static LocalizationManager i18n;

		internal static bool firstLaunch;

		internal static Harmony harmony;

		private bool debugMode;

		internal static bool needUpdate => UpdateChecker.CheckForUpdate();

		public void Awake()
		{
			instance = this;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin BattleImprove is loading!");
			LoggingInfo("Loading config...", needDebug: true);
			Config.InitConifg(((BaseUnityPlugin)this).Config);
			LoggingInfo("Config is loaded!", needDebug: true);
			LoggingInfo("Start patching...", needDebug: true);
			Patching();
			LoggingInfo("Patching is done!", needDebug: true);
			((MonoBehaviour)this).StartCoroutine(Prefab.LoadAssetBundle());
			Logger.LogInfo((object)"Plugin BattleImprove is loaded!");
		}

		private void Start()
		{
			LoggingInfo("Plugin is starting...");
			((MonoBehaviour)this).StartCoroutine(Init());
		}

		private void OnDestroy()
		{
			harmony.UnpatchSelf();
		}

		private IEnumerator Init()
		{
			LoggingInfo("Waiting for game boost...", needDebug: true);
			yield return (object)new WaitForSeconds(10f);
			LoggingInfo("Start Init!", needDebug: true);
			StaticInstance.InitGameObject();
		}

		private void Patching()
		{
			harmony = Harmony.CreateAndPatchAll(typeof(StaticInstance), (string)null);
			if (Config.EnableExpShare.Value)
			{
				harmony.PatchAll(typeof(ExpSharePatch));
			}
			if (Config.EnableHealthBar.Value)
			{
				harmony.PatchAll(typeof(HealthBarPatch));
			}
			if (Config.EnableLoopDropVFX.Value)
			{
				harmony.PatchAll(typeof(LootDropPatch));
			}
			if (Config.EnableSoundFeedback.Value)
			{
				harmony.PatchAll(typeof(SoundPatch));
			}
			if (Config.EnableDamageMessage.Value)
			{
				harmony.PatchAll(typeof(DamageInfoPatch));
				harmony.PatchAll(typeof(KillMessagePatch));
			}
			if (Config.EnableXCrossHair.Value)
			{
				harmony.PatchAll(typeof(CrossHairPatch));
			}
		}

		public void LoggingInfo(string info, bool needDebug = false)
		{
			if (needDebug)
			{
				if (debugMode)
				{
					Logger.LogInfo((object)("Debug info: " + info));
				}
			}
			else
			{
				Logger.LogInfo((object)info);
			}
		}
	}
	public class Config
	{
		internal static ConfigEntry<bool> EnableHealthBar;

		internal static ConfigEntry<bool> EnableExpShare;

		internal static ConfigEntry<bool> EnableSoundFeedback;

		internal static ConfigEntry<bool> EnableDeadUnitCollision;

		internal static ConfigEntry<bool> EnableXCrossHair;

		internal static ConfigEntry<bool> EnableDamageMessage;

		internal static ConfigEntry<bool> EnableLoopDropVFX;

		internal static ConfigEntry<float> Proportion;

		public static void InitConifg(ConfigFile cfg)
		{
			ToggleConfigInit(cfg);
			ExpShareConfigInit(cfg);
		}

		private static void ToggleConfigInit(ConfigFile cfg)
		{
			EnableExpShare = cfg.Bind<bool>("Toggle/开关", "EnableExpShare", true, "Enable experience share/是否开启经验共享");
			EnableHealthBar = cfg.Bind<bool>("Toggle/开关", "EnableHealthBar", true, "Enable health bar/是否开启血条");
			EnableXCrossHair = cfg.Bind<bool>("Toggle/开关", "EnableHitFeedback", true, "Enable xCrossHair feedback/是否开启击中准心反馈");
			EnableSoundFeedback = cfg.Bind<bool>("Toggle/开关", "EnableSoundFeedback", true, "Enable hit sound feedback on enemies/是否开启敌人受击声音反馈");
			EnableDamageMessage = cfg.Bind<bool>("Toggle/开关", "EnableDamageMessage", true, "Enable damage and kill message/是否开启伤害与击杀信息");
			EnableDeadUnitCollision = cfg.Bind<bool>("Toggle/开关", "EnableDeadUnitCollision", true, "Enable bullet will bounce on deadbody/是否开启子弹会在尸体上反弹");
			EnableLoopDropVFX = cfg.Bind<bool>("Toggle/开关", "EnableLoopDropVFX", true, "Enable loot drop VFX/是否开启掉落特效");
		}

		private static void ExpShareConfigInit(ConfigFile cfg)
		{
			Proportion = cfg.Bind<float>("ExpShare/经验共享", "Proportion", 0.5f, "The proportion of experience shared to second weapon/共享给第二把武器的经验比例");
		}
	}
	[Serializable]
	public class PluginData
	{
		public class Version : PluginData
		{
			public KeyCode menuKey = (KeyCode)282;

			public string version => "1.2.0";
		}

		public class AttackFeedback : PluginData
		{
			public float indicatorVolume = 0.5f;

			public float indicatorDistance = 0.5f;

			public float indicatorDistanceFar = 0.5f;

			public float indicatorDistanceHeadShoot = 0.5f;

			public Color hitColor = Color.white;

			public Color killColor = Color.red;

			public int messageStyle;

			public float messageVolume = 0.5f;
		}

		[NonSerialized]
		internal static Dictionary<string, PluginData> DataDict;

		public static bool SetupData()
		{
			try
			{
				if (SulfurSave.KeyExists("CmPlugin", (ES3Settings)null))
				{
					DataDict = SulfurSave.Load<Dictionary<string, PluginData>>("CmPlugin", new Dictionary<string, PluginData>(), (ES3Settings)null);
					VerifyData();
					return false;
				}
				Plugin.instance.LoggingInfo("Save data not found, creating new one...", needDebug: true);
				LoadDefaults();
				Plugin.instance.LoggingInfo("Save data created!", needDebug: true);
			}
			catch (Exception value)
			{
				Console.WriteLine(value);
				Plugin.instance.LoggingInfo("Failed to load save data, creating new one...", needDebug: true);
				LoadDefaults();
				throw;
			}
			return true;
		}

		private static void LoadDefaults()
		{
			DataDict = new Dictionary<string, PluginData>
			{
				{
					"BattleImprove",
					new Version()
				},
				{
					"AttackFeedback",
					new AttackFeedback()
				}
			};
			SaveData();
		}

		private static void VerifyData()
		{
			if (!DataDict.ContainsKey("BattleImprove"))
			{
				DataDict.Add("BattleImprove", new Version());
			}
			if (!DataDict.ContainsKey("AttackFeedback"))
			{
				DataDict.Add("AttackFeedback", new AttackFeedback());
			}
		}

		public static void SaveData()
		{
			SulfurSave.Save<Dictionary<string, PluginData>>("CmPlugin", DataDict);
		}
	}
	public class StaticInstance
	{
		internal static GameObject PluginGameObject;

		internal static GameObject IndicatorGameObject;

		internal static Npc[] Enemies;

		internal static List<Unit> KilledEnemies;

		internal static HitSoundEffect HitSoundClips;

		internal static xCrossHair CrossHair;

		internal static KillMessage KillMessage;

		internal static DamageInfo DamageInfo;

		public static void InitGameObject()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("CmPlugin");
			if ((Object)(object)val == (Object)null)
			{
				PluginGameObject = new GameObject("CmPlugin");
				Object.DontDestroyOnLoad((Object)(object)PluginGameObject);
			}
			else
			{
				PluginGameObject = val;
			}
			Plugin.i18n = new LocalizationManager();
			Plugin.i18n.LoadLocalization(Application.systemLanguage);
			LoadPrefab();
			Plugin.firstLaunch = PluginData.SetupData();
			GameObject val2 = new GameObject("Menu");
			val2.transform.parent = PluginGameObject.transform;
			val2.AddComponent<MenuController>();
		}

		internal static void LoadPrefab()
		{
			IndicatorGameObject = Prefab.LoadPrefab("AttackFeedback", PluginGameObject);
			HitSoundClips = PluginGameObject.GetComponentInChildren<HitSoundEffect>();
			CrossHair = PluginGameObject.GetComponentInChildren<xCrossHair>();
			KillMessage = PluginGameObject.GetComponentInChildren<KillMessage>();
			DamageInfo = PluginGameObject.GetComponentInChildren<DamageInfo>();
		}

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		[HarmonyPatch(typeof(InputReader), "LoadingContinue")]
		private static void AddFrame()
		{
			Enemies = StaticInstance<UnitManager>.Instance.GetAllEnemies();
			KilledEnemies = new List<Unit>();
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "BattleImprove";

		public const string PLUGIN_NAME = "Battle Improvements";

		public const string PLUGIN_VERSION = "1.2.0";
	}
}
namespace BattleImprove.Utils
{
	public class LocalizationManager
	{
		public enum SupportedLanguages
		{
			English,
			ChineseSimplified
		}

		public interface II18N
		{
			protected string GetText(string key)
			{
				return Plugin.i18n.GetText(key);
			}
		}

		private static Dictionary<string, string> localizationText = new Dictionary<string, string>();

		private static SystemLanguage currentLanguage;

		public void LoadLocalization(SystemLanguage language)
		{
			//IL_002d: 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_0024: 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)
			if (Enum.GetNames(typeof(SupportedLanguages)).Contains<string>(((object)(SystemLanguage)(ref language)).ToString()))
			{
				currentLanguage = language;
			}
			else
			{
				currentLanguage = (SystemLanguage)10;
			}
			localizationText.Clear();
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string text = $"BattleImprove.Lang.{currentLanguage}.lang";
			using Stream stream = executingAssembly.GetManifestResourceStream(text);
			if (stream == null)
			{
				Debug.LogError((object)("Failed to load localization file: " + text));
				return;
			}
			using StreamReader streamReader = new StreamReader(stream);
			string[] array = streamReader.ReadToEnd().Split('\n');
			foreach (string text2 in array)
			{
				if (!string.IsNullOrWhiteSpace(text2) && !text2.StartsWith("#"))
				{
					string[] array2 = text2.Split('=', 2);
					if (array2.Length == 2)
					{
						localizationText[array2[0].Trim()] = array2[1].Trim();
					}
				}
			}
		}

		public string GetText(string key)
		{
			if (!localizationText.ContainsKey(key))
			{
				return key;
			}
			return localizationText[key];
		}
	}
	public class Prefab
	{
		internal static AssetBundle AssetBundle;

		public static Dictionary<string, GameObject> Prefabs = new Dictionary<string, GameObject>();

		public static IEnumerator LoadAssetBundle()
		{
			Plugin.instance.LoggingInfo("Loading Asset Bundle...", needDebug: true);
			AssetBundle = AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream("BattleImprove.Assets.battle_improve"));
			if ((Object)(object)AssetBundle == (Object)null)
			{
				Plugin.instance.LoggingInfo("Failed to load custom assets.");
				yield break;
			}
			AssetBundleRequest request2 = AssetBundle.LoadAssetAsync<GameObject>("AttackFeedback");
			yield return request2;
			Dictionary<string, GameObject> prefabs = Prefabs;
			Object asset = request2.asset;
			prefabs.Add("AttackFeedback", (GameObject)(object)((asset is GameObject) ? asset : null));
			for (int i = 1; i <= 5; i++)
			{
				request2 = AssetBundle.LoadAssetAsync<GameObject>("LoopDropTier" + i);
				yield return request2;
				Dictionary<string, GameObject> prefabs2 = Prefabs;
				string key = "LoopDropTier" + i;
				Object asset2 = request2.asset;
				prefabs2.Add(key, (GameObject)(object)((asset2 is GameObject) ? asset2 : null));
			}
		}

		public static GameObject LoadPrefab(string name, GameObject parent)
		{
			Plugin.instance.LoggingInfo("Loading " + name + " Prefab...", needDebug: true);
			return Object.Instantiate<GameObject>(Prefabs[name], parent.transform, true);
		}
	}
	public class UpdateChecker
	{
		private const string UPDATE_URL = "https://api.github.com/repos/CmmmmmmLau/SulFur_Battle_improvement/releases/latest";

		public static bool CheckForUpdate()
		{
			using WebClient webClient = new WebClient();
			webClient.Headers.Add("User-Agent", "UnityModUpdater");
			try
			{
				string json = webClient.DownloadString("https://api.github.com/repos/CmmmmmmLau/SulFur_Battle_improvement/releases/latest");
				string current = "1.2.0";
				string text = ExtractVersionFromJson(json);
				if (CheckUpdate(current, text))
				{
					Plugin.Logger.LogInfo((object)("New version available: " + text));
					return true;
				}
				Plugin.Logger.LogInfo((object)"No new version available.");
				return false;
			}
			catch (WebException ex)
			{
				Plugin.Logger.LogError((object)("Failed to check for update: " + ex.Message));
			}
			return true;
		}

		private static bool CheckUpdate(string current, string latest)
		{
			Version version = new Version(current);
			return new Version(latest) > version;
		}

		private static string ExtractVersionFromJson(string json)
		{
			int num = json.IndexOf("\"tag_name\":\"") + 12;
			int num2 = json.IndexOf("\",", num);
			return json.Substring(num, num2 - num).Replace("v", "");
		}
	}
}
namespace BattleImprove.UI.InGame
{
	public class WindowAttackFeedback : WindowBase
	{
		private PluginData.AttackFeedback data;

		private WLabel label;

		private string resourcePack
		{
			get
			{
				if (!((Object)(object)StaticInstance.IndicatorGameObject == (Object)null))
				{
					return i18n.GetText("AttackFeedback.resource.loaded");
				}
				return i18n.GetText("AttackFeedback.resource.missed");
			}
		}

		protected override void Init()
		{
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			data = PluginData.DataDict["AttackFeedback"] as PluginData.AttackFeedback;
			window = UWindow.Begin("Attack Feedback", 200f, 10f, 22f, 5f, true, true, true);
			UWindow obj = window;
			obj.Width += 50f;
			StartPosition(310, 100);
			label = window.Label(i18n.GetText("AttackFeedback.resource") + ":" + resourcePack);
			window.Button("Reload", (Action)ReloadPrefab);
			window.Space();
			window.Label(i18n.GetText("AttackFeedback.indicator"));
			window.Slider(i18n.GetText("AttackFeedback.volume"), (Action<float>)SetIndicatorVolume, data.indicatorVolume, 0f, 1f, true, "0.##");
			window.Slider(i18n.GetText("AttackFeedback.distance"), (Action<float>)SetIndicatorDistance, data.indicatorDistance, 0f, 1f, true, "0.##");
			window.Slider(i18n.GetText("AttackFeedback.distance.far"), (Action<float>)SetIndicatorDistanceFar, data.indicatorDistanceFar, 0f, 1f, true, "0.##");
			window.Slider(i18n.GetText("AttackFeedback.distance.headshot"), (Action<float>)SetIndicatorDistanceHeadshoot, data.indicatorDistanceHeadShoot, 0f, 1f, true, "0.##");
			window.Space();
			window.Label(i18n.GetText("AttackFeedback.cross"));
			window.ColorPicker(i18n.GetText("AttackFeedback.hitcolor"), (Action<Color>)SetHitColor, data.hitColor);
			window.ColorPicker(i18n.GetText("AttackFeedback.killcolor"), (Action<Color>)SetChangeKillColor, data.killColor);
			window.Space();
			window.Label(i18n.GetText("AttackFeedback.message"));
			window.DropDown(i18n.GetText("AttackFeedback.style"), (Action<int>)SetKillMessageStyle, data.messageStyle, new Dictionary<int, string> { { 0, "Battlefield 1" } });
			window.Slider(i18n.GetText("AttackFeedback.volume"), (Action<float>)SetKillMessageVolume, data.messageVolume, 0f, 1f, true, "0.##");
			window.Button(i18n.GetText("AttackFeedback.test"), (Action)TestKillMessage);
			window.Space();
			base.Init();
		}

		private void ReloadPrefab()
		{
			if ((Object)(object)StaticInstance.IndicatorGameObject == (Object)null)
			{
				StaticInstance.LoadPrefab();
			}
			FieldInfo field = typeof(WLabel).GetField("DisplayedString", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field != null)
			{
				field.SetValue(label, i18n.GetText("AttackFeedback.resource") + ":" + resourcePack);
			}
		}

		private void SetIndicatorVolume(float value)
		{
			data.indicatorVolume = value;
		}

		private void SetIndicatorDistance(float value)
		{
			data.indicatorDistance = value;
		}

		private void SetIndicatorDistanceFar(float value)
		{
			data.indicatorDistanceFar = value;
		}

		private void SetIndicatorDistanceHeadshoot(float value)
		{
			data.indicatorDistanceHeadShoot = value;
		}

		private void SetHitColor(Color color)
		{
			//IL_0006: 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)
			data.hitColor = color;
		}

		private void SetChangeKillColor(Color color)
		{
			//IL_0006: 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)
			data.killColor = color;
		}

		private void SetKillMessageStyle(int value)
		{
			data.messageStyle = value;
		}

		private void SetKillMessageVolume(float value)
		{
			data.messageVolume = value;
		}

		private void TestKillMessage()
		{
			StaticInstance.KillMessage.OnEnemyKill(isHeadShot: false);
			StaticInstance.KillMessage.AddKillMessage("Enemy Name", "Weapon Name", "0");
		}
	}
	public class WindowBase : MonoBehaviour
	{
		public UWindow window;

		internal MenuController controller;

		protected LocalizationManager i18n = Plugin.i18n;

		protected virtual void Start()
		{
			Init();
		}

		public void Destroy()
		{
			Object.Destroy((Object)(object)this);
		}

		public virtual void Toggle()
		{
			window.IsDrawing = !window.IsDrawing;
		}

		internal WindowBase StartPosition(int x, int y)
		{
			window.X = x;
			window.Y = y;
			return this;
		}

		internal WindowBase SetController(MenuController controller)
		{
			this.controller = controller;
			return this;
		}

		protected virtual void Init()
		{
			window.Space();
			window.Button("Close", (Action)Close);
			window.IsDrawing = false;
		}

		protected virtual void Close()
		{
			window.IsDrawing = false;
		}
	}
	public class WindowHotkey : WindowBase
	{
		private WLabel label;

		private bool needInput;

		private KeyCode key;

		protected override void Init()
		{
			window = UWindow.Begin(i18n.GetText("Hotkey.title"), 200f, 10f, 22f, 5f, true, true, true);
			PluginData.Version version = PluginData.DataDict["BattleImprove"] as PluginData.Version;
			label = window.Label(i18n.GetText("Hotkey.current") + " " + ((object)(KeyCode)(ref version.menuKey)).ToString());
			StartPosition(350, 350);
			base.Init();
		}

		public override void Toggle()
		{
			base.Toggle();
			needInput = window.IsDrawing;
		}

		private void Update()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!needInput)
			{
				return;
			}
			Event current = Event.current;
			if (current.isKey)
			{
				key = current.keyCode;
				FieldInfo field = typeof(WLabel).GetField("DisplayedString", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field != null)
				{
					field.SetValue(label, i18n.GetText("Hotkey.current") + " " + ((object)(KeyCode)(ref key)).ToString());
				}
			}
		}

		protected override void Close()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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)
			(PluginData.DataDict["BattleImprove"] as PluginData.Version).menuKey = (KeyCode)(((int)key == 0) ? 282 : ((int)key));
			PluginData.SaveData();
			base.Close();
		}
	}
	public class WindowMenu : WindowBase
	{
		protected override void Init()
		{
			window = UWindow.Begin("Battle Improvement", 200f, 10f, 22f, 5f, true, true, true);
			StartPosition(100, 100);
			window.Button(i18n.GetText("AttackFeedback"), (Action)delegate
			{
				OpenSubMenu("AttackFeedback");
			});
			window.Button(i18n.GetText("Settings"), (Action)delegate
			{
				OpenSubMenu("Setting");
			});
			base.Init();
		}

		protected override void Close()
		{
			base.Close();
			controller.CloseSubWindow();
			controller.Pause(state: false);
		}

		private void OpenSubMenu(string name)
		{
			controller.OpenSubWindow(name);
		}
	}
	public class WindowSetting : WindowBase
	{
		protected override void Init()
		{
			window = UWindow.Begin(i18n.GetText("Settings"), 200f, 10f, 22f, 5f, true, true, true);
			UWindow obj = window;
			obj.Width += 50f;
			StartPosition(310, 100);
			window.Button(i18n.GetText("Reset"), (Action)Reset);
			window.Button(i18n.GetText("Hotkey"), (Action)ChangeMenuKey);
			base.Init();
		}

		private void Reset()
		{
			controller.ResetWindow();
		}

		private void ChangeMenuKey()
		{
			controller.OpenSubWindow("Hotkey", closeCurrent: false);
		}
	}
	public class WindowUpdateCheck : WindowBase
	{
		protected override void Start()
		{
			if (Plugin.needUpdate)
			{
				Init();
			}
			else
			{
				Object.Destroy((Object)(object)this);
			}
		}

		protected override void Init()
		{
			window = UWindow.Begin("Update Check", 200f, 10f, 22f, 5f, true, true, true);
			StartPosition(350, 350);
			window.Space();
			window.Label(Plugin.i18n.GetText("NeedUpdate"));
			window.Label(Plugin.i18n.GetText("NeedUpdate.Current") + "1.2.0");
			window.Label(Plugin.i18n.GetText("NeedUpdate.Text"));
			base.Init();
			window.IsDrawing = true;
			((MonoBehaviour)this).StartCoroutine(AutoClose());
		}

		private IEnumerator AutoClose()
		{
			yield return (object)new WaitForSeconds(5f);
			Close();
			Destroy();
		}
	}
}
namespace BattleImprove.Patcher.BattleFeedback
{
	[HarmonyPatch(typeof(Hitbox), "TakeHit", new Type[]
	{
		typeof(float),
		typeof(DamageType),
		typeof(DamageSourceData),
		typeof(Vector3)
	})]
	public class SoundPatch
	{
		private static PluginData.AttackFeedback data;

		private static void Postfix(Hitbox __instance, DamageType damageType, Vector3 collisionPoint)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_00a3: Invalid comparison between Unknown and I4
			//IL_00c2: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)StaticInstance.HitSoundClips == (Object)null)
			{
				return;
			}
			if (data == null)
			{
				data = PluginData.DataDict["AttackFeedback"] as PluginData.AttackFeedback;
			}
			if (__instance.Owner is Breakable || __instance.Owner.isPlayer)
			{
				return;
			}
			Npc component = ((Component)__instance.GetOwner()).gameObject.GetComponent<Npc>();
			if ((int)((Unit)component).UnitState != 0 && StaticInstance.Enemies.Contains(component))
			{
				float num = Vector3.Distance(StaticInstance<GameManager>.Instance.GetPlayerUnit().EyesPosition, ((Component)component).transform.position);
				GameObject player = StaticInstance<GameManager>.Instance.GetPlayer();
				if ((int)damageType.id == 1 || __instance.bodyPart.label == "Head")
				{
					Vector3 position = Vector3.LerpUnclamped(player.transform.position, collisionPoint, data.indicatorDistanceHeadShoot);
					StaticInstance.HitSoundClips.PlayHitSound(position, isCrit: true, isFar: false, data.indicatorVolume);
				}
				else if (num < 20f)
				{
					Vector3 position2 = Vector3.LerpUnclamped(player.transform.position, collisionPoint, data.indicatorDistance);
					StaticInstance.HitSoundClips.PlayHitSound(position2, isCrit: false, isFar: false, data.indicatorVolume);
				}
				else
				{
					Vector3 position3 = Vector3.LerpUnclamped(player.transform.position, collisionPoint, data.indicatorDistanceFar);
					StaticInstance.HitSoundClips.PlayHitSound(position3, isCrit: false, isFar: true, data.indicatorVolume);
				}
			}
		}
	}
}
namespace BattleImprove.Patcher.TakeHitPatcher
{
	public class AttackFeedbackPatch
	{
		protected static bool TargetCheck(DamageSourceData source, Hitbox instance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!source.sourceUnit.isPlayer)
			{
				return false;
			}
			if (instance.Owner is Breakable || instance.Owner.isPlayer)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Hitbox), "TakeHit", new Type[]
	{
		typeof(float),
		typeof(DamageType),
		typeof(DamageSourceData),
		typeof(Vector3)
	})]
	public class CrossHairPatch : AttackFeedbackPatch
	{
		private static void Prefix(Hitbox __instance, out bool __state)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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_0010: Invalid comparison between Unknown and I4
			UnitState unitState = __instance.Owner.UnitState;
			bool flag = unitState - 1 <= 1;
			__state = flag;
		}

		private static void Postfix(Hitbox __instance, ref DamageSourceData source, bool __state)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)StaticInstance.CrossHair == (Object)null) && AttackFeedbackPatch.TargetCheck(source, __instance) && __state)
			{
				PlayHitAnimation(__instance.Owner);
			}
		}

		private static bool PlayHitAnimation(Unit unit)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			UnitState unitState = unit.UnitState;
			bool flag = unitState - 1 <= 1;
			bool flag2 = flag;
			if (Config.EnableXCrossHair.Value && flag2)
			{
				StaticInstance.CrossHair.StartTrigger("Hit");
			}
			else
			{
				StaticInstance.CrossHair.StartTrigger("Kill");
			}
			return flag2;
		}
	}
	[HarmonyPatch(typeof(Hitbox), "TakeHit", new Type[]
	{
		typeof(float),
		typeof(DamageType),
		typeof(DamageSourceData),
		typeof(Vector3)
	})]
	public class DamageInfoPatch : AttackFeedbackPatch
	{
		private static void Prefix(Hitbox __instance, out float __state)
		{
			__state = __instance.Owner.GetCurrentHealth();
		}

		private static void Postfix(Hitbox __instance, DamageType damageType, ref DamageSourceData source, Vector3 collisionPoint, float __state)
		{
			//IL_000f: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)StaticInstance.DamageInfo == (Object)null || !AttackFeedbackPatch.TargetCheck(source, __instance) || !Config.EnableDamageMessage.Value)
			{
				return;
			}
			float num = __state - __instance.Owner.GetCurrentHealth();
			if (num > 0f)
			{
				string text = "";
				if (source.sourceWeapon.IsMelee)
				{
					text += ((ItemDefinition)source.sourceWeapon.weaponDefinition).displayName;
				}
				else
				{
					string[] obj = new string[6]
					{
						text,
						damageType.shortLabel,
						" ",
						source.sourceProjectile.CurrentCaliber.label,
						" ",
						null
					};
					ProjectileTypes projectileType = source.sourceProjectile.projectileType;
					obj[5] = ((object)(ProjectileTypes)(ref projectileType)).ToString();
					text = string.Concat(obj);
				}
				StaticInstance.DamageInfo.ShowDamageInfo(text, Convert.ToInt32(num));
			}
		}
	}
	[HarmonyPatch(typeof(Hitbox), "TakeHit", new Type[]
	{
		typeof(float),
		typeof(DamageType),
		typeof(DamageSourceData),
		typeof(Vector3)
	})]
	public class KillMessagePatch : AttackFeedbackPatch
	{
		private static void Postfix(Hitbox __instance, ref DamageSourceData source, Vector3 collisionPoint)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (AttackFeedbackPatch.TargetCheck(source, __instance) && !((Object)(object)StaticInstance.KillMessage == (Object)null) && !IsAlive(__instance.Owner))
			{
				PlayKillAudio(__instance, source.sourceWeapon, collisionPoint);
				ShowKillMessage(__instance.Owner, source.sourceWeapon);
			}
		}

		private static void PlayKillAudio(Hitbox hitbox, Weapon weapon, Vector3 collisionPoint)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_001d: 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: Invalid comparison between Unknown and I4
			float num = Vector3.Distance(StaticInstance<GameManager>.Instance.GetPlayerUnit().EyesPosition, collisionPoint);
			HoldableWeightClass holdableWeightClass = ((Holdable)weapon).holdableWeightClass;
			bool flag = holdableWeightClass - 3 <= 1;
			bool flag2 = flag;
			if (num > 20f && flag2)
			{
				StaticInstance.KillMessage.OnEnemyKill(hitbox.bodyPart.label == "Head");
			}
			else
			{
				StaticInstance.KillMessage.OnEnemyKill(isHeadShot: false);
			}
		}

		private static void ShowKillMessage(Unit enemy, Weapon weapon)
		{
			string sourceName = enemy.SourceName;
			string displayName = ((ItemDefinition)weapon.weaponDefinition).displayName;
			string exp = Convert.ToString(enemy.ExperienceOnKill);
			StaticInstance.KillMessage.AddKillMessage(sourceName, displayName, exp);
		}

		private static bool IsAlive(Unit unit)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			UnitState unitState = unit.UnitState;
			if (unitState - 1 <= 1)
			{
				return true;
			}
			if (StaticInstance.KilledEnemies.Contains(unit) || !unit.LastDamagedBy.sourceUnit.isPlayer)
			{
				return true;
			}
			StaticInstance.KilledEnemies.Add(unit);
			return false;
		}
	}
}
namespace BattleImprove.Patcher.QOL
{
	public class DeadUnitCollisionPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(Projectile), "ReportBounceOnHitbox")]
		private static bool CheckPass(Projectile __instance, Hitbox hitbox)
		{
			Plugin.instance.LoggingInfo("Projectile " + ((Object)__instance).name + " hit " + ((Object)hitbox).name);
			return false;
		}
	}
	public class ExpSharePatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Npc), "GiveExperience")]
		private static void GiveExperiencePrePatch(Npc __instance)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			InventorySlot key = (InventorySlot)(((int)((Holdable)StaticInstance<GameManager>.Instance.GetPlayerUnit().lastUsedWeapon).inventorySlot == 4) ? 5 : 4);
			Dictionary<InventorySlot, InventoryItem> equippedHoldables = ((Component)StaticInstance<GameManager>.Instance.GetPlayerUnit()).GetComponent<EquipmentManager>().EquippedHoldables;
			float num = ((Unit)__instance).ExperienceOnKill;
			float value = Config.Proportion.Value;
			if (equippedHoldables.ContainsKey(key))
			{
				equippedHoldables[key].AddExperience(num * value);
			}
		}
	}
	public class HealthBarPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(UnitDebugFrame), "Update")]
		private static bool UpdateHPBar(UnitDebugFrame __instance)
		{
			if (StaticInstance<DevToolsManager>.Instance.shouldShow)
			{
				return true;
			}
			((Component)__instance).transform.LookAt(((Component)StaticInstance<GameManager>.Instance.currentCamera).transform);
			HealthBar component = ((Component)__instance.owner).GetComponent<HealthBar>();
			if (component.UpdateValue())
			{
				Traverse.Create((object)__instance).Method("UpdateValues", Array.Empty<object>()).GetValue();
			}
			if (__instance.owner.IsAlive)
			{
				return false;
			}
			((Behaviour)component).enabled = false;
			((Component)__instance).gameObject.SetActive(false);
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Npc), "Start")]
		private static void AddDebugFrame(Player __instance)
		{
			((Component)__instance).gameObject.AddComponent<HealthBar>();
		}
	}
	public class LootDropPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Pickup), "Spawn")]
		private static void Postfix(Pickup __instance)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected I4, but got Unknown
			Plugin.instance.LoggingInfo("LootParticle Postfix", needDebug: true);
			GameObject gameObject = ((Component)((Component)__instance).transform.Find("Shadow")).gameObject;
			Object.Destroy((Object)(object)gameObject.GetComponent<DecalProjector>());
			ItemQuality itemQuality = Traverse.Create((object)__instance).Field("item").GetValue<ItemDefinition>()
				.itemQuality;
			((GameObject)((int)itemQuality switch
			{
				0 => Prefab.LoadPrefab("LoopDropTier1", ((Component)__instance).gameObject), 
				1 => Prefab.LoadPrefab("LoopDropTier2", ((Component)__instance).gameObject), 
				2 => Prefab.LoadPrefab("LoopDropTier3", ((Component)__instance).gameObject), 
				3 => Prefab.LoadPrefab("LoopDropTier4", ((Component)__instance).gameObject), 
				4 => Prefab.LoadPrefab("LoopDropTier5", ((Component)__instance).gameObject), 
				_ => Prefab.LoadPrefab("LoopDropTier1", ((Component)__instance).gameObject), 
			})).GetComponent<LootDropVFX>().SetParent(gameObject);
		}
	}
}
namespace BattleImprove.Components
{
	public class HealthBar : MonoBehaviour
	{
		private Camera camera;

		private bool isInitialized;

		private Npc npc;

		private float timer;

		private void Start()
		{
			npc = ((Component)this).gameObject.GetComponent<Npc>();
			if (((Unit)npc).IsProtectedNpc)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			isInitialized = false;
			((MonoBehaviour)this).StartCoroutine(Initialize());
		}

		private void Update()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (isInitialized && ((Unit)npc).IsAlive)
			{
				Vector3 eyesPosition = ((Unit)npc).EyesPosition;
				timer += Time.deltaTime;
				((Component)((Unit)npc).debugFrame).gameObject.SetActive(CheckVisible(eyesPosition));
			}
		}

		private IEnumerator Initialize()
		{
			yield return (object)new WaitForSeconds(3f);
			StaticInstance<DevToolsManager>.Instance.AddDebugFrameToUnit((Unit)(object)npc);
			camera = StaticInstance<GameManager>.Instance.currentCamera;
			isInitialized = true;
		}

		private bool CheckVisible(Vector3 position)
		{
			//IL_0006: 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_000c: 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_001a: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector3 val = camera.WorldToViewportPoint(position);
				int result;
				if (val.z > 0f)
				{
					float x = val.x;
					if (x > 0f && x < 1f)
					{
						float y = val.y;
						if (y > 0f && y < 1f)
						{
							result = ((Vector3.Distance(position, ((Component)camera).transform.position) < 15f) ? 1 : 0);
							goto IL_0068;
						}
					}
				}
				result = 0;
				goto IL_0068;
				IL_0068:
				return (byte)result != 0;
			}
			catch
			{
				Plugin.Logger.LogInfo((object)"Player camera lost, trying to find it again");
				camera = StaticInstance<GameManager>.Instance.currentCamera;
				StaticInstance<DevToolsManager>.Instance.AddDebugFrameToUnit((Unit)(object)npc);
			}
			return false;
		}

		public bool UpdateValue()
		{
			if (!(timer > 0.25f))
			{
				return false;
			}
			timer = 0f;
			return true;
		}
	}
	public class MenuController : MonoBehaviour
	{
		protected Dictionary<string, WindowBase> windos = new Dictionary<string, WindowBase>();

		protected WindowBase currentWindow;

		protected WindowBase menu;

		protected KeyCode menuKey => (PluginData.DataDict["BattleImprove"] as PluginData.Version).menuKey;

		private void Start()
		{
			((Component)this).gameObject.AddComponent<WindowUpdateCheck>();
			InitWindow();
		}

		public void Update()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKeyDown(menuKey))
			{
				ToggleMenu();
			}
		}

		public void ResetWindow()
		{
			ToggleMenu();
			foreach (KeyValuePair<string, WindowBase> windo in windos)
			{
				windo.Value.Destroy();
			}
			windos.Clear();
			InitWindow();
		}

		private void InitWindow()
		{
			menu = ((Component)this).gameObject.AddComponent<WindowMenu>().SetController(this);
			windos.Add("Menu", menu);
			WindowBase value = ((Component)this).gameObject.AddComponent<WindowAttackFeedback>().SetController(this);
			windos.Add("AttackFeedback", value);
			WindowBase value2 = ((Component)this).gameObject.AddComponent<WindowSetting>().SetController(this);
			windos.Add("Setting", value2);
			WindowBase value3 = ((Component)this).gameObject.AddComponent<WindowHotkey>().SetController(this);
			windos.Add("Hotkey", value3);
		}

		public void ToggleMenu()
		{
			if ((Object)(object)menu.window.ActiveSkin == (Object)null)
			{
				UWindow.RestoreGlobalDefaultSkin();
			}
			menu.Toggle();
			if (menu.window.IsDrawing)
			{
				if ((Object)(object)currentWindow != (Object)null)
				{
					currentWindow.Toggle();
				}
				Pause(state: true);
			}
			else
			{
				CloseSubWindow();
				Pause(state: false);
				PluginData.SaveData();
			}
		}

		public void Pause(bool state)
		{
			GameManager instance = StaticInstance<GameManager>.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.ModifyCursorState((ControllerLockState)4, state);
				instance.ModifyControllerLock((ControllerLockState)4, state);
			}
		}

		public void OpenSubWindow(string name, bool closeCurrent = true)
		{
			if ((Object)(object)currentWindow != (Object)null && (Object)(object)currentWindow != (Object)(object)windos[name] && currentWindow.window.IsDrawing && closeCurrent)
			{
				currentWindow.Toggle();
			}
			if (closeCurrent)
			{
				currentWindow = windos[name];
				currentWindow.Toggle();
			}
			else
			{
				windos[name].Toggle();
			}
		}

		public void CloseSubWindow()
		{
			foreach (KeyValuePair<string, WindowBase> windo in windos)
			{
				windo.Value.window.IsDrawing = false;
			}
		}
	}
}