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.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using BattleImprove.Components;
using BattleImprove.Components.QOL;
using BattleImprove.Patcher.QOL;
using BattleImprove.Patcher.TakeHitPatcher;
using BattleImprove.Transpiler;
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.LevelGeneration;
using PerfectRandom.Sulfur.Core.Stats;
using PerfectRandom.Sulfur.Core.UI;
using PerfectRandom.Sulfur.Core.Units;
using PerfectRandom.Sulfur.Core.Weapons;
using PerfectRandom.Sulfur.Core.World;
using PerfectRandom.Sulfur.Gameplay;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using UrGUI.UWindow;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("Cmmmmmm")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("GPL-3.0 license")]
[assembly: AssemblyFileVersion("1.5.0.0")]
[assembly: AssemblyInformationalVersion("1.5.0+72546d4097d348a77d99f675e149631f568a1039")]
[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.5.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 HitSoundEffect : PluginInstance<HitSoundEffect>
{
	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 BF5MessageController : MessageController
{
	public KillStreakController headshotStreak;

	public KillStreakController killStreak;

	protected override GameObject GetDamageInfo(string type, int damage, GameObject placeholder)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		GameObject damageInfo = base.GetDamageInfo(type, damage, placeholder);
		damageInfo.transform.localPosition = new Vector3(0f, 0f, 0f);
		damageInfo.GetComponent<RectTransform>().pivot = new Vector2(0.5f, 0.5f);
		TMP_Text component = damageInfo.GetComponent<TMP_Text>();
		component.alignment = (TextAlignmentOptions)514;
		component.fontSize = 15f;
		return damageInfo;
	}

	public override void OnEnemyKill(string enemyName, string weaponName, string exp, bool isHeadShot, bool isFar = false)
	{
		base.OnEnemyKill(enemyName, weaponName, exp, isHeadShot, isFar);
		if (isHeadShot)
		{
			headshotStreak.AddKillStreak();
		}
		else
		{
			killStreak.AddKillStreak();
		}
		headshotStreak.ResetTimer();
		killStreak.ResetTimer();
	}
}
public class DamageSource : MonoBehaviour
{
	public string damageType;

	public int damage;

	public TMP_Text message;

	private float timer;

	private GameObject placeholder;

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

	private void Update()
	{
		//IL_000c: 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_002c: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.position = Vector3.MoveTowards(((Component)this).transform.position, placeholder.transform.position, 200f * Time.deltaTime);
		timer += Time.deltaTime;
		if (timer > 5f)
		{
			Object.Destroy((Object)(object)placeholder);
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}

	public void InitMessage(string type, int damage, GameObject placeholder)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.localPosition = new Vector3(0f, 0f, 0f);
		((Component)this).transform.position = placeholder.transform.position;
		damageType = type;
		this.damage = damage;
		message.text = damageType + " " + damage;
		this.placeholder = placeholder;
		Reset();
	}

	public void Reset()
	{
		timer = 0f;
		message.text = damageType + " " + damage;
	}
}
public class KillStreakController : MonoBehaviour
{
	public GameObject FirstStreak;

	public TMP_Text streakCounter;

	public GameObject iconPrefab;

	public GameObject container;

	private float timer;

	private int streakCount;

	private void Start()
	{
		streakCounter.text = "";
		timer = 0f;
	}

	private void Update()
	{
		if (!Object.op_Implicit((Object)(object)FirstStreak))
		{
			return;
		}
		timer += Time.deltaTime;
		if (timer > 6f)
		{
			StreakIcon[] componentsInChildren = container.GetComponentsInChildren<StreakIcon>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].Fade();
			}
			timer = 0f;
			streakCount = 0;
			streakCounter.text = "";
		}
	}

	public void ResetTimer()
	{
		timer = 0f;
	}

	public void AddKillStreak()
	{
		GameObject placeholder = GetPlaceholder();
		LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)this).GetComponent<RectTransform>());
		GameObject val = Object.Instantiate<GameObject>(iconPrefab, container.transform, false);
		val.GetComponent<StreakIcon>().InitStrekIcon(placeholder, this);
		streakCount++;
		if (!Object.op_Implicit((Object)(object)FirstStreak))
		{
			FirstStreak = val;
		}
		if (streakCount % 5 == 0)
		{
			((Component)streakCounter).gameObject.SetActive(true);
			StreakIcon[] componentsInChildren = container.GetComponentsInChildren<StreakIcon>();
			foreach (StreakIcon streakIcon in componentsInChildren)
			{
				if ((Object)(object)((Component)streakIcon).gameObject != (Object)(object)FirstStreak && !streakIcon.NeedDestroyWhenOnPosition)
				{
					streakIcon.TargetPosition = FirstStreak;
					streakIcon.NeedDestroyWhenOnPosition = true;
				}
			}
			streakCounter.text = "×" + streakCount;
		}
		timer = 0f;
	}

	protected virtual GameObject GetPlaceholder()
	{
		//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)
		//IL_002e: 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_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Expected O, but got Unknown
		GameObject val = new GameObject("Placeholder", new Type[1] { typeof(RectTransform) });
		val.transform.SetParent(((Component)this).transform);
		val.transform.SetAsFirstSibling();
		val.GetComponent<RectTransform>().sizeDelta = new Vector2(25f, 25f);
		return val;
	}
}
public class MessageController : PluginInstance<MessageController>
{
	private GameObject banner;

	private TMP_Text tmpEnemyName;

	private TMP_Text tmpWeaponName;

	private TMP_Text tmpExp;

	private Animator bannerAnim;

	private bool isShowing;

	public AudioClip killSound;

	public AudioClip headShotKillSound;

	private AudioSource audioSource;

	private GameObject gameobjectTotalDamage;

	private TMP_Text tmpTotalDamage;

	private float timer;

	private int totalDamage;

	private int currentDamage;

	private GameObject damageInfoPlaceholder;

	private GameObject damageInfoContainer;

	private GameObject firstMessage;

	public GameObject damageSourcePrefab;

	internal PluginData.AttackFeedback data;

	protected override void Awake()
	{
		isShowing = false;
		InitBanner();
		InitDamageInfo();
		ResetDamageCounter();
		base.Awake();
	}

	protected virtual GameObject InitDamageInfo()
	{
		GameObject gameObject = ((Component)((Component)this).transform.Find("Damage")).gameObject;
		gameobjectTotalDamage = ((Component)gameObject.transform.Find("Total")).gameObject;
		tmpTotalDamage = gameobjectTotalDamage.GetComponent<TMP_Text>();
		damageInfoPlaceholder = ((Component)gameObject.transform.Find("Placeholder")).gameObject;
		damageInfoContainer = ((Component)gameObject.transform.Find("Container")).gameObject;
		return gameObject;
	}

	protected virtual GameObject InitBanner()
	{
		banner = ((Component)((Component)this).transform.Find("Banner")).gameObject;
		tmpEnemyName = ((Component)FindChild(banner.transform, "Enemy")).GetComponent<TMP_Text>();
		tmpWeaponName = ((Component)FindChild(banner.transform, "Weapon")).GetComponent<TMP_Text>();
		tmpExp = ((Component)FindChild(banner.transform, "Exp")).GetComponent<TMP_Text>();
		bannerAnim = banner.GetComponent<Animator>();
		audioSource = banner.GetComponent<AudioSource>();
		return banner;
	}

	protected virtual void Start()
	{
		data = DataManager.AttackFeedbackData;
	}

	protected void Update()
	{
		UpdateTotalDamage();
		if (isShowing && (timer += Time.deltaTime) > 5f)
		{
			ResetDamageCounter();
			HideMessage();
		}
	}

	public virtual void OnEnemyKill(string enemyName, string weaponName, string exp, bool isHeadShot, bool isFar = false)
	{
		tmpEnemyName.text = enemyName;
		tmpWeaponName.text = weaponName;
		tmpExp.text = exp;
		((MonoBehaviour)this).StartCoroutine(ShowMessage());
		PlayKillAudio(isHeadShot, isFar);
	}

	public void OnEnemyHit(string type, int damage)
	{
		gameobjectTotalDamage.SetActive(true);
		totalDamage += damage;
		if ((Object)(object)firstMessage != (Object)null && (Object)(object)damageInfoContainer != (Object)null)
		{
			DamageSource[] componentsInChildren = damageInfoContainer.GetComponentsInChildren<DamageSource>();
			foreach (DamageSource damageSource in componentsInChildren)
			{
				if (damageSource.damageType == type)
				{
					damageSource.damage += damage;
					damageSource.Reset();
					return;
				}
			}
		}
		AddDamageInfo(type, damage);
	}

	private static Transform FindChild(Transform parent, string name)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Expected O, but got Unknown
		foreach (Transform item in parent)
		{
			Transform val = item;
			if (((Object)val).name == name)
			{
				return val;
			}
			Transform val2 = FindChild(val, name);
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
		}
		return null;
	}

	public void HideMessage()
	{
		isShowing = false;
		bannerAnim.SetTrigger("Fade");
	}

	private void ResetDamageCounter()
	{
		gameobjectTotalDamage.SetActive(false);
		totalDamage = 0;
		currentDamage = 0;
		timer = 0f;
	}

	private IEnumerator ShowMessage()
	{
		if (!isShowing)
		{
			isShowing = true;
			bannerAnim.SetTrigger("Pop");
		}
		yield return (object)new WaitForEndOfFrame();
		Transform transform = banner.transform;
		LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((transform is RectTransform) ? transform : null));
	}

	private void UpdateTotalDamage()
	{
		if (currentDamage < totalDamage)
		{
			timer = 0f;
			int num = Mathf.Max(1, (totalDamage - currentDamage) / 100);
			currentDamage += num;
			tmpTotalDamage.text = currentDamage.ToString();
		}
	}

	protected virtual GameObject AddDamageInfo(string type, int damage)
	{
		GameObject placeholder = GetPlaceholder();
		LayoutRebuilder.ForceRebuildLayoutImmediate(damageInfoPlaceholder.GetComponent<RectTransform>());
		firstMessage = GetDamageInfo(type, damage, placeholder);
		return firstMessage;
	}

	protected virtual GameObject GetPlaceholder()
	{
		//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)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Expected O, but got Unknown
		GameObject val = new GameObject("Placeholder", new Type[1] { typeof(RectTransform) });
		val.transform.SetParent(damageInfoPlaceholder.transform);
		val.transform.SetAsFirstSibling();
		val.GetComponent<RectTransform>().sizeDelta = new Vector2(25f, 25f);
		return val;
	}

	protected virtual GameObject GetDamageInfo(string type, int damage, GameObject placeholder)
	{
		GameObject obj = Object.Instantiate<GameObject>(damageSourcePrefab, damageInfoContainer.transform);
		obj.GetComponent<DamageSource>().InitMessage(type, damage, placeholder);
		return obj;
	}

	protected virtual void PlayKillAudio(bool isHeadShot, bool isFar)
	{
		audioSource.PlayOneShot(isFar ? headShotKillSound : killSound, data.messageVolume);
	}
}
public class StreakIcon : MonoBehaviour
{
	private Animator animator;

	private KillStreakController controller;

	private GameObject targetPosition;

	private bool needDestroyWhenOnPosition;

	public GameObject TargetPosition
	{
		get
		{
			if (!((Object)(object)targetPosition == (Object)null))
			{
				return targetPosition;
			}
			return controller.FirstStreak;
		}
		set
		{
			if (Object.op_Implicit((Object)(object)targetPosition))
			{
				Object.Destroy((Object)(object)targetPosition);
			}
			targetPosition = value;
		}
	}

	public bool NeedDestroyWhenOnPosition
	{
		get
		{
			return needDestroyWhenOnPosition;
		}
		set
		{
			if (value)
			{
				needDestroyWhenOnPosition = value;
				((MonoBehaviour)this).StartCoroutine(DestroyWhenOnPosition());
			}
		}
	}

	private void Start()
	{
		animator = ((Component)this).GetComponent<Animator>();
	}

	private void Update()
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		if (Object.op_Implicit((Object)(object)TargetPosition))
		{
			((Component)this).transform.position = Vector3.MoveTowards(((Component)this).transform.position, TargetPosition.transform.position, 200f * Time.deltaTime);
		}
	}

	public void InitStrekIcon(GameObject placeholder, KillStreakController controller)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.localPosition = new Vector3(0f, 0f, 0f);
		((Component)this).transform.position = placeholder.transform.position;
		targetPosition = placeholder;
		needDestroyWhenOnPosition = false;
		this.controller = controller;
	}

	public void Destroy(float delay = 0f)
	{
		Object.Destroy((Object)(object)targetPosition.gameObject, delay);
		Object.Destroy((Object)(object)((Component)this).gameObject, delay);
	}

	private IEnumerator DestroyWhenOnPosition()
	{
		while (((Component)this).transform.position != targetPosition.transform.position)
		{
			yield return (object)new WaitForEndOfFrame();
		}
		Object.Destroy((Object)(object)((Component)this).gameObject);
	}

	public void Fade()
	{
		animator.SetTrigger("Fade");
		Destroy(0.25f);
	}
}
public class xCrossHair : PluginInstance<xCrossHair>
{
	public Animator crossHairAnim;

	private PluginData.AttackFeedback data;

	private Image[] images;

	private void Start()
	{
		data = DataManager.AttackFeedbackData;
		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)
		//IL_0034: 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_0071: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.localPosition = new Vector3(0f, 0.1f, 0f);
		((Component)this).transform.localScale = new Vector3(1f, 1f, 1f);
		ParticleSystem[] array = systems;
		foreach (ParticleSystem obj in array)
		{
			_ = parentObject.transform.localScale;
			((Component)obj).transform.localScale = new Vector3(0.4f, 0.4f, 0.4f);
		}
		isScaling = true;
		((MonoBehaviour)this).StartCoroutine(StopScale());
	}

	private void Update()
	{
		bool mouseButton = Input.GetMouseButton(1);
		ParticleSystem[] array = systems;
		for (int i = 0; i < array.Length; i++)
		{
			((Component)array[i]).gameObject.SetActive(!mouseButton);
		}
		_ = isScaling;
	}

	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.5.0")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		internal static Harmony Harmony;

		internal static LocalizationManager i18n;

		private static bool debugMode;

		internal static GameObject PluginGameObject;

		internal static GameObject IndicatorGameObject;

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

		public void Awake()
		{
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin BattleImprove 1.5.0 is loading!");
			Config.InitConfig(((BaseUnityPlugin)this).Config);
			Patching();
			((MonoBehaviour)this).StartCoroutine(PrefabManager.LoadAssetBundle());
			Logger.LogInfo((object)"Plugin BattleImprove is loaded!");
			((MonoBehaviour)this).StartCoroutine(InitPluginGameobject());
		}

		private IEnumerator InitPluginGameobject()
		{
			while (!SulfurSave.Imp.initialized || !PrefabManager.IsLoaded)
			{
				LoggingInfo("Waiting for game to load...");
				yield return (object)new WaitForSeconds(1f);
			}
			LoggingInfo("Starting plugin initialization...");
			LoggingInfo("Loading localization...");
			i18n = new LocalizationManager();
			i18n.LoadLocalization(Application.systemLanguage);
			LoggingInfo("Initializing plugin gameobject...");
			GameObject val = GameObject.Find("CmPlugin");
			if ((Object)(object)val == (Object)null)
			{
				PluginGameObject = new GameObject("CmPlugin");
				Object.DontDestroyOnLoad((Object)(object)PluginGameObject);
			}
			else
			{
				PluginGameObject = val;
			}
			LoggingInfo("Loading plugin data...");
			DataManager.SetUpData();
			LoggingInfo("Loading plugin prefab...");
			PrefabManager.LoadAttackFeedbackPrefab();
			LoggingInfo("Loading other gameobject...");
			PluginGameObject.AddComponent<LootSpawnHelper>();
			GameObject val2 = new GameObject("Menu");
			val2.transform.parent = PluginGameObject.transform;
			val2.AddComponent<MenuController>();
		}

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

		private void Patching()
		{
			LoggingInfo("Patching...", needDebug: true);
			Harmony = Harmony.CreateAndPatchAll(typeof(AttackFeedbackPatch), (string)null);
			Harmony.PatchAll(typeof(DataManager));
			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.EnableDeadUnitCollision.Value)
			{
				Harmony.PatchAll(typeof(RemoveDeadBodyCollisionTranspiler));
			}
			if (Config.EnableDeadProtection.Value)
			{
				Harmony.PatchAll(typeof(DeadProtection));
			}
			if (Config.ReverseMouseScroll.Value)
			{
				Harmony.PatchAll(typeof(MouseScrollTranspiler));
			}
			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));
			}
			LoggingInfo("Patching complete!");
		}

		public static 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<bool> EnableDeadProtection;

		internal static ConfigEntry<bool> ReverseMouseScroll;

		internal static ConfigEntry<float> Proportion;

		public static void InitConfig(ConfigFile cfg)
		{
			Plugin.LoggingInfo("Loading Config...");
			ToggleConfigInit(cfg);
			ExpShareConfigInit(cfg);
			OtherConfigInit(cfg);
			Plugin.LoggingInfo("Config Loaded.");
		}

		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, "Allowing bullets to pass through deadbody/是否使子弹能穿过尸体");
			EnableLoopDropVFX = cfg.Bind<bool>("Toggle/开关", "EnableLoopDropVFX", true, "Enable loot drop VFX/是否开启掉落特效");
			EnableDeadProtection = cfg.Bind<bool>("Toggle/开关", "EnableDeadProtection", true, "Enable dead protection/是否开启死亡保护");
		}

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

		private static void OtherConfigInit(ConfigFile cfg)
		{
			ReverseMouseScroll = cfg.Bind<bool>("Other/其他", "ReverseMouseScroll", true, "Reverse mouse scroll direction/反转鼠标滚轮方向");
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "BattleImprove";

		public const string PLUGIN_NAME = "Battle Improvements";

		public const string PLUGIN_VERSION = "1.5.0";
	}
}
namespace BattleImprove.Utils
{
	[HarmonyPatch]
	public static class DataManager
	{
		public static PluginData.Version VersionData;

		public static PluginData.AttackFeedback AttackFeedbackData;

		public static PluginData.DeadProtection DeadProtectionData;

		public static Dictionary<int, string> KillMessageStyle = new Dictionary<int, string>
		{
			{ 0, "Battlefield 1" },
			{ 1, "Battlefield 5" }
		};

		public static void SetUpData()
		{
			SaveManager.LoadSaveFile();
		}

		public static void SaveAllData()
		{
			SaveVersionData();
			SaveAttackMessageData();
			SaveDeadProtectionData();
		}

		public static void SaveVersionData(bool reset = false)
		{
			SaveManager.SaveVersionData();
		}

		public static void SaveAttackMessageData(bool reset = false)
		{
			SaveManager.SaveAttackMessageData();
		}

		public static void SaveDeadProtectionData(bool reset = false)
		{
			if (reset)
			{
				DeadProtectionData.opened = false;
			}
			if (DeadProtectionData.opened)
			{
				DeadProtectionData.weapons.Clear();
			}
			SaveManager.SaveDeadProtectionData();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PauseMenu), "ExitAction")]
		[HarmonyPatch(typeof(GameManager), "PlayerDied")]
		private static void ExitActionPostfix()
		{
			SaveAllData();
		}
	}
	public class LocalizationManager
	{
		public enum SupportedLanguages
		{
			English,
			ChineseSimplified
		}

		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];
		}
	}
	[Serializable]
	public class PluginData
	{
		public class Version : PluginData
		{
			public KeyCode menuKey = (KeyCode)282;

			public string version => "1.5.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;
		}

		public class DeadProtection : PluginData
		{
			public bool opened;

			public List<InventoryData> weapons = new List<InventoryData>();

			public float weaponDurability = 0.3f;

			public float attachmentChance = 0.3f;

			public float enchantmentChance = 0.3f;

			public float barrelChance = 0.3f;
		}
	}
	public abstract class PluginInstance<T> : MonoBehaviour where T : MonoBehaviour
	{
		public static T Instance;

		protected virtual void Awake()
		{
			Instance = (T)(object)((this is T) ? this : null);
			Plugin.LoggingInfo("PluginInstance<" + typeof(T).Name + "> initialized.");
		}

		protected virtual void OnDestroy()
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
	public static class PrefabManager
	{
		internal static AssetBundle AssetBundle;

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

		public static bool IsLoaded;

		public static IEnumerator LoadAssetBundle()
		{
			IsLoaded = false;
			Plugin.LoggingInfo("Loading Asset Bundle...", needDebug: true);
			AssetBundle = AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream("BattleImprove.Assets.battle_improve"));
			if ((Object)(object)AssetBundle == (Object)null)
			{
				Plugin.LoggingInfo("Failed to load custom assets.");
			}
			else
			{
				AssetBundleRequest request3 = AssetBundle.LoadAssetAsync<GameObject>("AttackFeedback");
				yield return request3;
				Dictionary<string, GameObject> prefabs = Prefabs;
				Object asset = request3.asset;
				prefabs.Add("AttackFeedback", (GameObject)(object)((asset is GameObject) ? asset : null));
				foreach (string style in DataManager.KillMessageStyle.Values)
				{
					request3 = AssetBundle.LoadAssetAsync<GameObject>(style);
					yield return request3;
					Dictionary<string, GameObject> prefabs2 = Prefabs;
					Object asset2 = request3.asset;
					prefabs2.Add(style, (GameObject)(object)((asset2 is GameObject) ? asset2 : null));
				}
				for (int i = 1; i <= 5; i++)
				{
					request3 = AssetBundle.LoadAssetAsync<GameObject>("LoopDropTier" + i);
					yield return request3;
					Dictionary<string, GameObject> prefabs3 = Prefabs;
					string key = "LoopDropTier" + i;
					Object asset3 = request3.asset;
					prefabs3.Add(key, (GameObject)(object)((asset3 is GameObject) ? asset3 : null));
				}
			}
			Plugin.LoggingInfo("Asset Bundle loaded!", needDebug: true);
			IsLoaded = true;
		}

		public static GameObject LoadPrefab(string name, GameObject parent)
		{
			Plugin.LoggingInfo("Loading " + name + " Prefab...", needDebug: true);
			return Object.Instantiate<GameObject>(Prefabs[name], parent.transform, true);
		}

		internal static void LoadAttackFeedbackPrefab()
		{
			Plugin.IndicatorGameObject = LoadPrefab("AttackFeedback", Plugin.PluginGameObject);
			LoadKillMessageStyle(DataManager.KillMessageStyle[DataManager.AttackFeedbackData.messageStyle]);
		}

		internal static void LoadKillMessageStyle(string style = "Battlefield 1")
		{
			if ((Object)(object)PluginInstance<MessageController>.Instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)PluginInstance<MessageController>.Instance).gameObject);
			}
			LoadPrefab(style, Plugin.IndicatorGameObject);
		}
	}
	public static class SaveManager
	{
		public const string SaveFileName = "BattleImproveSaveData";

		public static void LoadSaveFile()
		{
			try
			{
				if (ES3.KeyExists("CmPlugin", SulfurSave.Imp.saveSettings))
				{
					TransferSaveData();
				}
				if (ES3.FileExists("BattleImproveSaveData"))
				{
					LoadAll();
					return;
				}
				Plugin.LoggingInfo("Save data not found, creating new one...");
				LoadDefaults();
				Plugin.LoggingInfo("Save data created!");
			}
			catch (Exception value)
			{
				Console.WriteLine(value);
				Plugin.LoggingInfo("Failed to load save data, creating new one...");
				LoadDefaults();
				throw;
			}
		}

		private static void LoadAll()
		{
			LoadVersionData();
			LoadAttackMessageData();
			LoadDeadProtectionData();
		}

		private static void LoadDeadProtectionData()
		{
			DataManager.DeadProtectionData = ES3.Load<PluginData.DeadProtection>("DeadProtection", "BattleImproveSaveData", new PluginData.DeadProtection());
		}

		private static void LoadAttackMessageData()
		{
			DataManager.AttackFeedbackData = ES3.Load<PluginData.AttackFeedback>("AttackFeedback", "BattleImproveSaveData", new PluginData.AttackFeedback());
		}

		private static void LoadVersionData()
		{
			DataManager.VersionData = ES3.Load<PluginData.Version>("Version", "BattleImproveSaveData", new PluginData.Version());
		}

		public static void SaveAll()
		{
			SaveVersionData();
			SaveAttackMessageData();
			SaveDeadProtectionData();
		}

		public static void SaveVersionData()
		{
			ES3.Save<PluginData.Version>("Version", DataManager.VersionData, "BattleImproveSaveData");
		}

		public static void SaveAttackMessageData()
		{
			ES3.Save<PluginData.AttackFeedback>("AttackFeedback", DataManager.AttackFeedbackData, "BattleImproveSaveData");
		}

		public static void SaveDeadProtectionData(bool reset = false)
		{
			ES3.Save<PluginData.DeadProtection>("DeadProtection", DataManager.DeadProtectionData, "BattleImproveSaveData");
		}

		private static void TransferSaveData()
		{
			Plugin.LoggingInfo("Save data found in the vanilla save file, transfers it to the new file...");
			Dictionary<string, PluginData> dictionary = SulfurSave.Imp.Load<Dictionary<string, PluginData>>("CmPlugin", new Dictionary<string, PluginData>());
			ES3.DeleteKey("CmPlugin", SulfurSave.Imp.saveSettings);
			PluginData.Version version = dictionary["BattleImprove"] as PluginData.Version;
			Traverse.IterateFields((object)version, (Action<Traverse>)RoundUp);
			ES3.Save<PluginData.Version>("BattleImprove", version, "BattleImproveSaveData");
			PluginData.AttackFeedback attackFeedback = dictionary["AttackFeedback"] as PluginData.AttackFeedback;
			Traverse.IterateFields((object)attackFeedback, (Action<Traverse>)RoundUp);
			ES3.Save<PluginData.AttackFeedback>("AttackFeedback", attackFeedback, "BattleImproveSaveData");
			PluginData.DeadProtection deadProtection = dictionary["DeadProtection"] as PluginData.DeadProtection;
			Traverse.IterateFields((object)deadProtection, (Action<Traverse>)RoundUp);
			ES3.Save<PluginData.DeadProtection>("DeadProtection", deadProtection, "BattleImproveSaveData");
		}

		private static void RoundUp(Traverse traverse)
		{
			object value = traverse.GetValue();
			if (value is float)
			{
				float x = (float)value;
				traverse.SetValue((object)MathF.Round(x, 2));
			}
		}

		private static void LoadDefaults()
		{
			ES3.Save<PluginData.Version>("BattleImprove", new PluginData.Version(), "BattleImproveSaveData");
			ES3.Save<PluginData.AttackFeedback>("AttackFeedback", new PluginData.AttackFeedback(), "BattleImproveSaveData");
			ES3.Save<PluginData.DeadProtection>("DeadProtection", new PluginData.DeadProtection(), "BattleImproveSaveData");
			LoadAll();
		}
	}
	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.5.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 false;
			}
		}

		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)Plugin.IndicatorGameObject == (Object)null))
				{
					return i18n.GetText("AttackFeedback.resource.loaded");
				}
				return i18n.GetText("AttackFeedback.resource.missed");
			}
		}

		protected override void Init()
		{
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			data = DataManager.AttackFeedbackData;
			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, DataManager.KillMessageStyle);
			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)Plugin.IndicatorGameObject == (Object)null)
			{
				PrefabManager.LoadAttackFeedbackPrefab();
			}
			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 = MathF.Round(value, 2);
		}

		private void SetIndicatorDistance(float value)
		{
			data.indicatorDistance = MathF.Round(value, 2);
		}

		private void SetIndicatorDistanceFar(float value)
		{
			data.indicatorDistanceFar = MathF.Round(value, 2);
		}

		private void SetIndicatorDistanceHeadshoot(float value)
		{
			data.indicatorDistanceHeadShoot = MathF.Round(value, 2);
		}

		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;
			PrefabManager.LoadKillMessageStyle(DataManager.KillMessageStyle[value]);
		}

		private void SetKillMessageVolume(float value)
		{
			data.messageVolume = MathF.Round(value, 2);
		}

		private void TestKillMessage()
		{
			PluginInstance<MessageController>.Instance.OnEnemyKill("Enemy Name#" + Random.RandomRangeInt(0, 10), "Weapon Name#" + Random.RandomRangeInt(0, 10), Random.RandomRangeInt(0, 10).ToString(), Random.RandomRangeInt(0, 10) < 5, Random.RandomRangeInt(0, 10) < 5);
			PluginInstance<MessageController>.Instance.OnEnemyHit("Bullet Damage Type#" + Random.RandomRangeInt(0, 10), Random.RandomRangeInt(0, 100));
		}
	}
	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()
		{
			controller.SaveData();
			window.IsDrawing = false;
		}
	}
	public class WindowDeadProtection : WindowBase
	{
		private PluginData.DeadProtection data;

		protected override void Init()
		{
			data = DataManager.DeadProtectionData;
			window = UWindow.Begin("Dead Protection", 200f, 10f, 22f, 5f, true, true, true);
			UWindow obj = window;
			obj.Width += 50f;
			StartPosition(310, 100);
			window.Label(i18n.GetText("DeadProtection.durability"));
			window.Slider("", (Action<float>)OnDurabilityChange, data.weaponDurability, 0f, 1f, true, "0.##");
			window.Label(i18n.GetText("DeadProtection.barrel"));
			window.Slider("", (Action<float>)OnBarrelChange, data.barrelChance, 0f, 1f, true, "0.##");
			window.Label(i18n.GetText("DeadProtection.attachment"));
			window.Slider("", (Action<float>)OnAttachmentChange, data.attachmentChance, 0f, 1f, true, "0.##");
			window.Label(i18n.GetText("DeadProtection.enchantment"));
			window.Slider("", (Action<float>)OnEnchantmentChange, data.enchantmentChance, 0f, 1f, true, "0.##");
			base.Init();
		}

		private void OnDurabilityChange(float value)
		{
			data.weaponDurability = MathF.Round(value, 2);
		}

		private void OnAttachmentChange(float value)
		{
			data.attachmentChance = MathF.Round(value, 2);
		}

		private void OnEnchantmentChange(float value)
		{
			data.enchantmentChance = MathF.Round(value, 2);
		}

		private void OnBarrelChange(float value)
		{
			data.barrelChance = MathF.Round(value, 2);
		}
	}
	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 versionData = DataManager.VersionData;
			label = window.Label(i18n.GetText("Hotkey.current") + " " + ((object)(KeyCode)(ref versionData.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_0006: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			DataManager.VersionData.menuKey = (KeyCode)(((int)key == 0) ? 282 : ((int)key));
			DataManager.SaveAllData();
			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("DeadProtection"), (Action)delegate
			{
				OpenSubMenu("DeadProtection");
			});
			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(0, 0);
			window.Space();
			window.Label(Plugin.i18n.GetText("NeedUpdate"));
			window.Label(Plugin.i18n.GetText("NeedUpdate.Current") + "1.5.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.Transpiler
{
	public class MouseScrollTranspiler
	{
		[HarmonyTranspiler]
		[HarmonyPatch(typeof(InputReader), "SelectByScroll")]
		private static IEnumerable<CodeInstruction> ProjectileTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase original)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			CodeMatcher obj = new CodeMatcher(instructions, (ILGenerator)null).Start();
			CodeInstruction val = obj.Instructions()[4];
			if (val.opcode == OpCodes.Ble_Un_S || val.opcode == OpCodes.Ble_Un)
			{
				val.opcode = OpCodes.Bge_Un_S;
			}
			return obj.InstructionEnumeration();
		}
	}
	public class RemoveDeadBodyCollisionTranspiler
	{
		[HarmonyTranspiler]
		[HarmonyPatch(typeof(Projectile), "HandleHit")]
		private static IEnumerable<CodeInstruction> ProjectileTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase original)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).End();
			Label label = generator.DefineLabel();
			val.Instructions()[val.Instructions().Count - 2].labels.Add(label);
			val.MatchBack(true, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(Projectile), "remainingBounceHits"), (string)null)
			}).ThrowIfInvalid("Failed to find the target code in Projectile.HandleHit");
			if (val.IsValid)
			{
				CodeInstruction[] array = (CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldarg_2, (object)null),
					Transpilers.EmitDelegate<Func<Hitbox, bool>>((Func<Hitbox, bool>)CheckHitboxAlive),
					new CodeInstruction(OpCodes.Brfalse_S, (object)label)
				};
				val.Advance(3).InsertAndAdvance(array);
			}
			else
			{
				Plugin.LoggingInfo("Failed to find the target code in Projectile.HandleHit");
			}
			Plugin.LoggingInfo("ProjectileTranspiler Transpiler is working", needDebug: true);
			return val.InstructionEnumeration();
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(ProjectileSystem), "ProcessSortedHits")]
		private static IEnumerable<CodeInstruction> ProjectileSystemTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase original)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Expected O, but got Unknown
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Expected O, but got Unknown
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Expected O, but got Unknown
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			byte b = Convert.ToByte(2);
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).End();
			Label label = generator.DefineLabel();
			CodeMatch[] array = (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Ldarg_1), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Ldc_R4 && i.operand.Equals(0f)), (string)null)
			};
			CodeInstructionExtensions.WithLabels(val.MatchBack(false, array).ThrowIfInvalid("Failed to find the target code in in Line: 226 -> ptr.displacement = 0f;").Instruction, new Label[1] { label });
			array = (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null)
			};
			CodeInstruction[] array2 = (CodeInstruction[])(object)new CodeInstruction[3]
			{
				new CodeInstruction(OpCodes.Ldloc_S, (object)b),
				Transpilers.EmitDelegate<Func<Hitbox, bool>>((Func<Hitbox, bool>)CheckHitboxAlive),
				new CodeInstruction(OpCodes.Brfalse_S, (object)label)
			};
			val.MatchBack(false, array).ThrowIfInvalid("Failed to find the target code in Line: 225 -> ptr.velocity = Vector3.Reflect(ptr.velocity, raycastHit.normal) * num4;").Insert(array2);
			Label label2 = generator.DefineLabel();
			array = (CodeMatch[])(object)new CodeMatch[6]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloca_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Stfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_2, (object)null, (string)null)
			};
			CodeInstructionExtensions.WithLabels(val.MatchBack(true, array).ThrowIfInvalid("Failed to find the target code in Line: 182 -> ptr.position = raycastHit.point;").Instruction, new Label[1] { label2 });
			array2 = (CodeInstruction[])(object)new CodeInstruction[3]
			{
				CodeInstructionExtensions.MoveLabelsFrom(new CodeInstruction(OpCodes.Ldloc_S, (object)b), val.MatchBack(false, (CodeMatch[])(object)new CodeMatch[1] { array[0] }).Instruction),
				Transpilers.EmitDelegate<Func<Hitbox, bool>>((Func<Hitbox, bool>)CheckHitboxAlive),
				new CodeInstruction(OpCodes.Brfalse_S, (object)label2)
			};
			val.Insert(array2);
			Plugin.LoggingInfo("ProjectileSystemTranspiler Transpiler is working", needDebug: true);
			return val.InstructionEnumeration();
		}

		private static bool CheckHitboxAlive(Hitbox hitbox)
		{
			if ((Object)(object)hitbox == (Object)null)
			{
				return true;
			}
			bool flag = !hitbox.GetOwner().isNpc || hitbox.GetOwner().IsAlive;
			Plugin.LoggingInfo($"Checks whether to take over the bullet behavior: {flag}", needDebug: true);
			return flag;
		}
	}
}
namespace BattleImprove.Patcher.TakeHitPatcher
{
	public class AttackFeedbackPatch
	{
		internal static Npc[] Enemies;

		internal static List<Unit> KilledEnemies;

		[HarmonyWrapSafe]
		[HarmonyPostfix]
		[HarmonyPatch(typeof(InputReader), "LoadingContinue")]
		private static void ResetList()
		{
			Enemies = (from npc in StaticInstance<UnitManager>.Instance.GetAllNpcs(false)
				where ((Unit)npc).IsHostileTo(StaticInstance<GameManager>.Instance.PlayerUnit)
				select npc).ToArray();
			KilledEnemies = new List<Unit>();
		}

		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;
		}
	}
	[HarmonyWrapSafe]
	[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)PluginInstance<xCrossHair>.Instance == (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)
			{
				PluginInstance<xCrossHair>.Instance.StartTrigger("Hit");
			}
			else
			{
				PluginInstance<xCrossHair>.Instance.StartTrigger("Kill");
			}
			return flag2;
		}
	}
	[HarmonyWrapSafe]
	[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)
			if (!((Object)(object)PluginInstance<MessageController>.Instance == (Object)null) && AttackFeedbackPatch.TargetCheck(source, __instance) && Config.EnableDamageMessage.Value)
			{
				float num = __state - __instance.Owner.GetCurrentHealth();
				if (num > 0f)
				{
					string text = "";
					text = ((!source.sourceWeapon.IsMelee) ? (text + damageType.shortLabel + " " + source.sourceProjectile.CurrentCaliber.label + " " + ((object)(ProjectileTypes)(ref source.sourceProjectile.projectileType)).ToString()) : (text + ((ItemDefinition)source.sourceWeapon.weaponDefinition).displayName));
					PluginInstance<MessageController>.Instance.OnEnemyHit(text, Convert.ToInt32(num));
				}
			}
		}
	}
	[HarmonyWrapSafe]
	[HarmonyPatch(typeof(Hitbox), "TakeHit", new Type[]
	{
		typeof(float),
		typeof(DamageType),
		typeof(DamageSourceData),
		typeof(Vector3)
	})]
	public class KillMessagePatch : AttackFeedbackPatch
	{
		private static void Prefix(Hitbox __instance, out float __state)
		{
			__state = __instance.Owner.GetCurrentHealth();
		}

		private static void Postfix(Hitbox __instance, ref DamageSourceData source, Vector3 collisionPoint)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_0053: Invalid comparison between Unknown and I4
			if (!((Object)(object)PluginInstance<MessageController>.Instance == (Object)null) && AttackFeedbackPatch.TargetCheck(source, __instance) && !IsAlive(__instance.Owner))
			{
				float num = Vector3.Distance(StaticInstance<GameManager>.Instance.PlayerUnit.EyesPosition, collisionPoint);
				HoldableWeightClass holdableWeightClass = ((Holdable)source.sourceWeapon).holdableWeightClass;
				bool flag = holdableWeightClass - 3 <= 1;
				bool flag2 = flag;
				string sourceName = __instance.Owner.SourceName;
				string displayName = ((ItemDefinition)source.sourceWeapon.weaponDefinition).displayName;
				string text = Convert.ToString(__instance.Owner.ExperienceOnKill);
				Plugin.LoggingInfo("KillMessage: " + sourceName + " " + displayName + " " + text);
				PluginInstance<MessageController>.Instance.OnEnemyKill(sourceName, displayName, text, __instance.bodyPart.label == "Head", num > 20f && flag2);
			}
		}

		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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			UnitState unitState = unit.UnitState;
			if (unitState - 1 <= 1)
			{
				return true;
			}
			if ((Object)(object)unit.LastDamagedBy.sourceUnit == (Object)null)
			{
				return true;
			}
			if (AttackFeedbackPatch.KilledEnemies.Contains(unit) || !Object.op_Implicit((Object)(object)unit.LastDamagedBy.sourceUnit))
			{
				return true;
			}
			AttackFeedbackPatch.KilledEnemies.Add(unit);
			return false;
		}
	}
	[HarmonyWrapSafe]
	[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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_008b: Invalid comparison between Unknown and I4
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)PluginInstance<HitSoundEffect>.Instance == (Object)null)
			{
				return;
			}
			if (data == null)
			{
				data = DataManager.AttackFeedbackData;
			}
			if (__instance.Owner is Breakable || __instance.Owner.isPlayer)
			{
				return;
			}
			Npc component = ((Component)__instance.GetOwner()).gameObject.GetComponent<Npc>();
			if ((int)((Unit)component).UnitState != 0 && AttackFeedbackPatch.Enemies.Contains(component))
			{
				Unit playerUnit = StaticInstance<GameManager>.Instance.PlayerUnit;
				float num = Vector3.Distance(playerUnit.EyesPosition, ((Component)component).transform.position);
				if ((int)damageType.id == 1 || __instance.bodyPart.label == "Head")
				{
					Vector3 position = Vector3.LerpUnclamped(((Component)playerUnit).transform.position, collisionPoint, data.indicatorDistanceHeadShoot);
					PluginInstance<HitSoundEffect>.Instance.PlayHitSound(position, isCrit: true, isFar: false, data.indicatorVolume);
				}
				else if (num < 20f)
				{
					Vector3 position2 = Vector3.LerpUnclamped(((Component)playerUnit).transform.position, collisionPoint, data.indicatorDistance);
					PluginInstance<HitSoundEffect>.Instance.PlayHitSound(position2, isCrit: false, isFar: false, data.indicatorVolume);
				}
				else
				{
					Vector3 position3 = Vector3.LerpUnclamped(((Component)playerUnit).transform.position, collisionPoint, data.indicatorDistanceFar);
					PluginInstance<HitSoundEffect>.Instance.PlayHitSound(position3, isCrit: false, isFar: true, data.indicatorVolume);
				}
			}
		}
	}
}
namespace BattleImprove.Patcher.QOL
{
	public class DeadProtection
	{
		[HarmonyWrapSafe]
		[HarmonyPrefix]
		[HarmonyPatch(typeof(LootManager), "AddToChurchCollection")]
		private static void SavePlayerEquipment()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Invalid comparison between Unknown and I4
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: 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_0118: 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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: 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_0176: Expected O, but got Unknown
			Plugin.LoggingInfo("Player died, saving weapon! Quick!!!");
			PluginData.DeadProtection deadProtectionData = DataManager.DeadProtectionData;
			List<InventoryData> weapons = deadProtectionData.weapons;
			weapons.Clear();
			foreach (InventoryItem item3 in ((Component)StaticInstance<GameManager>.Instance.PlayerUnit).GetComponent<EquipmentManager>().EquippedHoldables.Select((KeyValuePair<InventorySlot, InventoryItem> item) => item.Value))
			{
				if ((int)item3.SlotType == 7)
				{
					ItemDefinition itemDefinition = item3.itemDefinition;
					WeaponSO val = (WeaponSO)(object)((itemDefinition is WeaponSO) ? itemDefinition : null);
					Plugin.LoggingInfo("Saved item: " + ((ItemDefinition)val).LocalizedDisplayName);
					Plugin.LoggingInfo("Durability Current: " + item3.DurabilityCurrent);
					item3.ModifyDurability((float)(-item3.DurabilityCurrent) * (1f - deadProtectionData.weaponDurability));
					Plugin.LoggingInfo("Durability Modified: " + item3.DurabilityCurrent);
					Plugin.LoggingInfo("Grabbing item data...");
					string identifier = ((ItemDefinition)val).identifier;
					Vector2Int val2 = item3.gridPosition;
					int x = ((Vector2Int)(ref val2)).x;
					val2 = item3.gridPosition;
					int y = ((Vector2Int)(ref val2)).y;
					int quantity = item3.quantity;
					int currentAmmo = item3.currentAmmo;
					string identifier2 = item3.CurrentCaliber.identifier;
					ItemAttributeCollectionData obj = item3.stats.SerializedAttributeData();
					string[] serializedAttachments = item3.GetSerializedAttachments();
					string[] serializedEnchantments = item3.GetSerializedEnchantments();
					val2 = item3.InventorySize;
					int x2 = ((Vector2Int)(ref val2)).x;
					val2 = item3.InventorySize;
					InventoryData item2 = new InventoryData(identifier, x, y, quantity, currentAmmo, identifier2, obj, serializedAttachments, serializedEnchantments, x2, ((Vector2Int)(ref val2)).y, false, false);
					Plugin.LoggingInfo("Saving item data...");
					weapons.Add(item2);
				}
			}
			DataManager.SaveDeadProtectionData(reset: true);
		}

		[HarmonyWrapSafe]
		[HarmonyPostfix]
		[HarmonyPatch(typeof(ChurchCollectionLootable), "Loot")]
		private static void ReturnPlayerEquipment(ChurchCollectionLootable __instance)
		{
			Plugin.LoggingInfo("Donation box opened, popping equipment back!");
			Transform val = Traverse.Create((object)__instance).Field("lootSpawnTransform").GetValue<Transform>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)__instance).transform;
			}
			PluginData.DeadProtection deadProtectionData = DataManager.DeadProtectionData;
			PluginInstance<LootSpawnHelper>.Instance.SpawnItems(deadProtectionData, val);
		}
	}
	public class ExpSharePatch
	{
		[HarmonyWrapSafe]
		[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.PlayerUnit.lastUsedWeapon).inventorySlot == 4) ? 5 : 4);
			Dictionary<InventorySlot, InventoryItem> equippedHoldables = ((Component)StaticInstance<GameManager>.Instance.PlayerUnit).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
	{
		[HarmonyWrapSafe]
		[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
	{
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		[HarmonyPatch(typeof(Pickup), "SetupAndSpawn")]
		private static void SetupAndSpawnPostfix(Pickup __instance)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected I4, but got Unknown
			Plugin.LoggingInfo("LootParticle Postfix", needDebug: true);
			Plugin.LoggingInfo("LootParticle Hide Postfix", needDebug: true);
			LootDropVFX componentInChildren = ((Component)__instance).GetComponentInChildren<LootDropVFX>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)componentInChildren).gameObject);
				Plugin.LoggingInfo("LootParticle Destroyed", needDebug: true);
			}
			else
			{
				Plugin.LoggingInfo("LootParticle not found", needDebug: true);
			}
			GameObject gameObject = ((Component)((Component)__instance).transform.Find("Shadow")).gameObject;
			ItemQuality itemQuality = __instance.ItemSO.itemQuality;
			((GameObject)((int)itemQuality switch
			{
				0 => PrefabManager.LoadPrefab("LoopDropTier1", ((Component)__instance).gameObject), 
				1 => PrefabManager.LoadPrefab("LoopDropTier2", ((Component)__instance).gameObject), 
				2 => PrefabManager.LoadPrefab("LoopDropTier3", ((Component)__instance).gameObject), 
				3 => PrefabManager.LoadPrefab("LoopDropTier4", ((Component)__instance).gameObject), 
				4 => PrefabManager.LoadPrefab("LoopDropTier5", ((Component)__instance).gameObject), 
				_ => PrefabManager.LoadPrefab("LoopDropTier1", ((Component)__instance).gameObject), 
			})).GetComponent<LootDropVFX>().SetParent(gameObject);
		}
	}
}
namespace BattleImprove.Components
{
	public class MenuController : PluginInstance<MenuController>
	{
		protected Dictionary<string, WindowBase> windos = new Dictionary<string, WindowBase>();

		protected WindowBase currentWindow;

		protected WindowBase menu;

		protected KeyCode menuKey => DataManager.VersionData.menuKey;

		private void Start()
		{
			((Component)this).gameObject.AddComponent<WindowUpdateCheck>().SetController(this);
			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<WindowDeadProtection>().SetController(this);
			windos.Add("DeadProtection", value2);
			WindowBase value3 = ((Component)this).gameObject.AddComponent<WindowSetting>().SetController(this);
			windos.Add("Setting", value3);
			WindowBase value4 = ((Component)this).gameObject.AddComponent<WindowHotkey>().SetController(this);
			windos.Add("Hotkey", value4);
		}

		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);
			}
			SaveData();
		}

		public void SaveData()
		{
			DataManager.SaveAllData();
		}

		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;
			}
		}
	}
}
namespace BattleImprove.Components.QOL
{
	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 LootSpawnHelper : PluginInstance<LootSpawnHelper>
	{
		private PluginData.DeadProtection data;

		private void Start()
		{
			data = DataManager.DeadProtectionData;
		}

		public void SpawnItems(PluginData.DeadProtection keptItems, Transform transform)
		{
			((MonoBehaviour)this).StartCoroutine(SpawnWeapon(keptItems.weapons, transform));
			keptItems.opened = true;
		}

		private IEnumerator SpawnWeapon(List<InventoryData> weapons, Transform transform)
		{
			foreach (InventoryData weapon in weapons)
			{
				ItemDefinition item = StaticInstance<LootManager>.Instance.GetItem(weapon.identifier);
				weapon.attachments = RandomDeleteElement(weapon.attachments, data.attachmentChance);
				weapon.enchantments = RandomDeleteElement(weapon.enchantments, data.enchantmentChance);
				weapon.caliber = RandomDeleteElement(new string[1] { weapon.caliber }, data.barrelChance)[0];
				Room currentRoom = StaticInstance<GameManager>.Instance.PlayerUnit.currentRoom;
				StaticInstance<InteractionManager>.Instance.SpawnPickup(new Vector3(transform.position.x, transform.position.y, transform.position.z + 0.08f), false, item, currentRoom, weapon, (Container)null, 0.75f);
				yield return (object)new WaitForSeconds(1f);
			}
		}

		private string[] RandomDeleteElement(string[] array, float chance)
		{
			List<string> list = new List<string>(array);
			foreach (string item in list.ToList())
			{
				float num = Random.Range(0f, 1f);
				Plugin.LoggingInfo("Rolling for " + item + " with chance " + chance + " got " + num);
				if (num < chance)
				{
					list.Remove(item);
				}
			}
			return list.ToArray();
		}
	}
}