using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FMOD;
using FMODUnity;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;
using UnityEngine.Localization.Tables;

[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("NightWolfHawk")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+71efdebfbc8b9be62fa68a9147899d0dc6f137b0")]
[assembly: AssemblyProduct("NightWolfHawk")]
[assembly: AssemblyTitle("NightWolfHawk")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace NightWolfHawk
{
	public static class NightWolfHawkRules
	{
		public static float WeightForFiftyPercentChance(float existingPoolWeight)
		{
			return Math.Max(0f, existingPoolWeight);
		}

		public static bool ShouldRequestStartingItem(bool debugEnabled, bool alreadyRequested)
		{
			if (debugEnabled)
			{
				return !alreadyRequested;
			}
			return false;
		}

		public static bool ShouldDistractRecipient(bool isSender, bool isReady)
		{
			return !isSender && isReady;
		}

		public static bool ShouldSelfTarget(int opponentCount, bool debugEnabled)
		{
			if (debugEnabled)
			{
				return opponentCount == 0;
			}
			return false;
		}

		public static bool ShouldConsumeItem(int connectedPlayerCount, bool infiniteSoloUses)
		{
			if (infiniteSoloUses)
			{
				return connectedPlayerCount > 1;
			}
			return true;
		}
	}
	[BepInPlugin("com.shadowforce.sbg.nightwolfhawk", "Night Wolf Hawk", "0.7.5")]
	public sealed class Plugin : BaseUnityPlugin
	{
		private enum ScreenEdge
		{
			Bottom,
			Top,
			Left,
			Right
		}

		[HarmonyPatch(typeof(BNetworkManager), "OnStartClient")]
		private static class NetworkRegistrationPatch
		{
			private static void Postfix()
			{
				RegisterNetworkMessages();
			}
		}

		[HarmonyPatch(typeof(ItemCollection), "Initialize")]
		private static class ItemCollectionPatch
		{
			private static readonly FieldInfo ItemsField = AccessTools.Field(typeof(ItemCollection), "items");

			private static readonly FieldInfo ItemDataField = AccessTools.Field(typeof(ItemCollection), "allItemData");

			private static void Postfix(ItemCollection __instance)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Expected I4, but got Unknown
				Dictionary<ItemType, ItemData> dictionary = (Dictionary<ItemType, ItemData>)ItemDataField.GetValue(__instance);
				if (dictionary.ContainsKey(Item) || !dictionary.TryGetValue((ItemType)4, out var value))
				{
					return;
				}
				ItemData val = new ItemData();
				PropertyInfo[] properties = typeof(ItemData).GetProperties(BindingFlags.Instance | BindingFlags.Public);
				foreach (PropertyInfo propertyInfo in properties)
				{
					if (propertyInfo.CanRead && propertyInfo.CanWrite)
					{
						propertyInfo.SetValue(val, propertyInfo.GetValue(value));
					}
				}
				AccessTools.Property(typeof(ItemData), "Type").SetValue(val, Item);
				AccessTools.Property(typeof(ItemData), "MaxUses").SetValue(val, 1);
				AccessTools.Property(typeof(ItemData), "Icon").SetValue(val, Instance?._icon);
				val.Initialize();
				ItemData[] array = (ItemData[])ItemsField.GetValue(__instance);
				Array.Resize(ref array, array.Length + 1);
				array[^1] = val;
				ItemsField.SetValue(__instance, array);
				dictionary[Item] = val;
				Log.LogInfo((object)$"[Night Wolf Hawk] Registered item type {(int)Item}.");
			}
		}

		[HarmonyPatch(typeof(ItemSpawnerSettings), "ResetRuntimeData")]
		private static class ItemSpawnerPatch
		{
			private static readonly FieldInfo SpawnChancesField = AccessTools.Field(typeof(ItemPool), "spawnChances");

			private static readonly FieldInfo TotalWeightField = AccessTools.Field(typeof(ItemPool), "totalSpawnChanceWeight");

			private static void Postfix(ItemSpawnerSettings __instance)
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)__instance.AheadOfBallItemPool == (Object)null))
				{
					SpawnWeights[0] = Inject(__instance.AheadOfBallItemPool);
					for (int i = 0; i < __instance.ItemPools.Count && i + 1 < SpawnWeights.Length; i++)
					{
						SpawnWeights[i + 1] = Inject(__instance.ItemPools[i].pool);
					}
					Log.LogInfo((object)"[Night Wolf Hawk] Added to regular item pools (50% each; mobility: 0%).");
				}
			}

			private static float Inject(ItemPool pool)
			{
				//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_003c: 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_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: 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_00df: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)pool == (Object)null)
				{
					return 0f;
				}
				ItemSpawnChance[] array = ((ItemSpawnChance[])SpawnChancesField.GetValue(pool)) ?? Array.Empty<ItemSpawnChance>();
				ItemSpawnChance[] array2 = array;
				foreach (ItemSpawnChance val in array2)
				{
					if (val.item == Item)
					{
						return val.spawnChanceWeight;
					}
				}
				float num = 0f;
				array2 = array;
				foreach (ItemSpawnChance val2 in array2)
				{
					num += val2.spawnChanceWeight;
				}
				float num2 = NightWolfHawkRules.WeightForFiftyPercentChance(num);
				if (num2 <= 0f)
				{
					return 0f;
				}
				ItemSpawnChance[] array3 = (ItemSpawnChance[])(object)new ItemSpawnChance[array.Length + 1];
				Array.Copy(array, array3, array.Length);
				array3[^1] = new ItemSpawnChance
				{
					item = Item,
					spawnChanceWeight = num2
				};
				SpawnChancesField.SetValue(pool, array3);
				TotalWeightField.SetValue(pool, num + num2);
				return num2;
			}
		}

		[HarmonyPatch(typeof(MatchSetupRules), "GetWeight")]
		private static class MatchSetupWeightPatch
		{
			private static void Postfix(int poolIndex, ItemType itemType, ref float __result)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				if (itemType == Item && poolIndex >= 0 && poolIndex < SpawnWeights.Length)
				{
					__result = SpawnWeights[poolIndex];
				}
			}
		}

		[HarmonyPatch(typeof(MatchSetupRules), "GetDefaultWeight")]
		private static class MatchSetupDefaultWeightPatch
		{
			private static void Postfix(int poolIndex, ItemType itemType, ref float __result)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				if (itemType == Item && poolIndex >= 0 && poolIndex < SpawnWeights.Length)
				{
					__result = SpawnWeights[poolIndex];
				}
			}
		}

		[HarmonyPatch(typeof(MatchSetupRules), "GetDefaultItemFactor")]
		private static class MatchSetupDefaultFactorPatch
		{
			private static void Postfix(int poolIndex, ItemType itemType, ref float __result)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				if (itemType == Item)
				{
					__result = ((poolIndex >= 0 && poolIndex < SpawnWeights.Length) ? 0.5f : 0f);
				}
			}
		}

		[HarmonyPatch]
		private static class MatchSetupCustomWeightChangedPatch
		{
			private static readonly MethodInfo UpdateTotalWeightMethod = AccessTools.Method(typeof(MatchSetupRules), "UpdateTotalWeightForPool", (Type[])null, (Type[])null);

			private static MethodBase TargetMethod()
			{
				return AccessTools.Method(typeof(MatchSetupRules), "OnSpawnChanceWeightsChangedInItemPool", new Type[1] { typeof(ItemPoolId) }, (Type[])null);
			}

			private static bool Prefix(MatchSetupRules __instance, ItemPoolId itemPoolId)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				if (itemPoolId.itemType != Item)
				{
					return true;
				}
				UpdateTotalWeightMethod.Invoke(__instance, new object[1] { itemPoolId.itemPoolIndex });
				return false;
			}
		}

		[HarmonyPatch(typeof(MatchSetupRules), "Update")]
		private static class MatchSetupUpdatePatch
		{
			private static readonly FieldInfo CurrentItemPoolDirtyField = AccessTools.Field(typeof(MatchSetupRules), "currentItemPoolDirty");

			private static readonly MethodInfo GetCurrentItemPoolMethod = AccessTools.Method(typeof(MatchSetupRules), "GetCurrentItemPool", (Type[])null, (Type[])null);

			private static readonly FieldInfo CurrentItemPoolIndexField = AccessTools.Field(typeof(MatchSetupRules), "currentItemPoolIndex");

			private static readonly FieldInfo SpawnChanceWeightsField = AccessTools.Field(typeof(MatchSetupRules), "spawnChanceWeights");

			private static readonly FieldInfo SpawnChanceSlidersField = AccessTools.Field(typeof(MatchSetupRules), "spawnChanceSliders");

			private static bool Prefix(MatchSetupRules __instance)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Expected O, but got Unknown
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Expected I4, but got Unknown
				//IL_0118: 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)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				if (!MatchSetupMenu.IsActive)
				{
					return false;
				}
				if (!(bool)CurrentItemPoolDirtyField.GetValue(__instance))
				{
					return false;
				}
				ItemPool val = (ItemPool)GetCurrentItemPoolMethod.Invoke(__instance, null);
				int num = (int)CurrentItemPoolIndexField.GetValue(__instance);
				IDictionary<ItemPoolId, float> dictionary = (IDictionary<ItemPoolId, float>)SpawnChanceWeightsField.GetValue(__instance);
				List<SliderOption> list = (List<SliderOption>)SpawnChanceSlidersField.GetValue(__instance);
				int[] itemOrderLookup = __instance.itemOrderLookup;
				float num2 = 0f;
				ItemSpawnChance[] spawnChances = val.SpawnChances;
				foreach (ItemSpawnChance val2 in spawnChances)
				{
					ItemPoolId key = ItemPoolId.Get(num, val2.item);
					if (dictionary.ContainsKey(key))
					{
						num2 += dictionary[key];
					}
				}
				spawnChances = val.SpawnChances;
				foreach (ItemSpawnChance val3 in spawnChances)
				{
					if (val3.item == Item)
					{
						continue;
					}
					int num3 = val3.item - 1;
					if (num3 >= 0 && num3 < itemOrderLookup.Length)
					{
						int num4 = itemOrderLookup[num3];
						if (num4 >= 0 && num4 < list.Count)
						{
							ItemPoolId key2 = ItemPoolId.Get(num, val3.item);
							float num5 = ((num2 > float.Epsilon && dictionary.ContainsKey(key2)) ? (dictionary[key2] / num2) : 0f);
							list[num4].SetValueText($"{num5 * 100f:0.#}%");
						}
					}
				}
				CurrentItemPoolDirtyField.SetValue(__instance, false);
				return false;
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static class ItemNamePatch
		{
			private static bool Prefix(ItemData __instance, ref string __result)
			{
				//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)
				if (__instance.Type != Item)
				{
					return true;
				}
				__result = "Night Wolf Hawk";
				return false;
			}
		}

		[HarmonyPatch(typeof(PlayerInventory), "ServerTryAddItem")]
		private static class AddItemPatch
		{
			private static readonly FieldInfo SlotsField = AccessTools.Field(typeof(PlayerInventory), "slots");

			private static bool Prefix(PlayerInventory __instance, ItemType itemToAdd, int remainingUses, ref bool __result)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				if (itemToAdd != Item)
				{
					return true;
				}
				int index = default(int);
				if (!NetworkServer.active || !__instance.HasSpaceForItem(ref index))
				{
					__result = false;
					return false;
				}
				((IList<InventorySlot>)SlotsField.GetValue(__instance))[index] = new InventorySlot(Item, Math.Max(1, remainingUses));
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(PlayerInventory), "GetEffectivelyEquippedItem")]
		private static class EquippedItemPatch
		{
			private static void Postfix(PlayerInventory __instance, bool ignoreEquipmentHiding, ref ItemType __result)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				if (!ignoreEquipmentHiding && __instance.GetEffectivelyEquippedItem(true) == Item)
				{
					__result = (ItemType)4;
				}
			}
		}

		[HarmonyPatch(typeof(PlayerInventory), "TryUseItem")]
		private static class UseItemPatch
		{
			private static bool Prefix(PlayerInventory __instance, ref bool shouldEatInput, ref bool __result)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.GetEffectivelyEquippedItem(true) != Item)
				{
					return true;
				}
				if (!NetworkClient.active || !NetworkClient.ready || __instance.EquippedItemIndex < 0)
				{
					__result = false;
					return false;
				}
				NetworkClient.Send<NightWolfHawkUseRequest>(new NightWolfHawkUseRequest
				{
					SlotIndex = __instance.EquippedItemIndex
				}, 0);
				shouldEatInput = true;
				__result = true;
				return false;
			}
		}

		public const string PluginGuid = "com.shadowforce.sbg.nightwolfhawk";

		public const string PluginName = "Night Wolf Hawk";

		public const string PluginVersion = "0.7.5";

		public const string ItemName = "Night Wolf Hawk";

		public static readonly ItemType Item = (ItemType)220;

		internal static Plugin? Instance;

		internal static ManualLogSource Log = null;

		internal static ConfigEntry<bool> GrantStartingItem = null;

		internal static ConfigEntry<bool> SelfTargetWhenAlone = null;

		internal static ConfigEntry<bool> AutoUseWhenAlone = null;

		internal static ConfigEntry<bool> InfiniteUsesWhenAlone = null;

		private Harmony? _harmony;

		private PlayerInventory? _announcedInventory;

		private bool _itemNameRegistered;

		private Texture2D? _image;

		private Sprite? _icon;

		private readonly List<string> _sounds = new List<string>();

		private float _distractionStartedAt = float.NegativeInfinity;

		private float _distractionDuration;

		private ScreenEdge _screenEdge;

		private const float SlideInSeconds = 0.45f;

		private const float SlideOutSeconds = 0.55f;

		private const float MinimumVisibleSeconds = 3.5f;

		private const float BottomCrop = 36f;

		private static readonly float[] SpawnWeights = new float[5];

		private string AssetDirectory => Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "assets");

		private void Awake()
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			GrantStartingItem = ((BaseUnityPlugin)this).Config.Bind<bool>("Testing", "GrantStartingItem", false, "Add Night Wolf Hawk to your inventory when joining for testing.");
			SelfTargetWhenAlone = ((BaseUnityPlugin)this).Config.Bind<bool>("Testing", "SelfTargetWhenAlone", false, "Echo the distraction to the user when no opponents are connected.");
			AutoUseWhenAlone = ((BaseUnityPlugin)this).Config.Bind<bool>("Testing", "AutoUseWhenAlone", false, "Automatically use Night Wolf Hawk after joining a solo session.");
			InfiniteUsesWhenAlone = ((BaseUnityPlugin)this).Config.Bind<bool>("Testing", "InfiniteUsesWhenAlone", true, "Do not consume Night Wolf Hawk when it is used in a solo session.");
			LoadImage();
			LoadSounds();
			_harmony = new Harmony("com.shadowforce.sbg.nightwolfhawk");
			_harmony.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Night Wolf Hawk 0.7.5 loaded (no Issa dependency).");
		}

		private void OnDestroy()
		{
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			if ((Object)(object)_icon != (Object)null)
			{
				Object.Destroy((Object)(object)_icon);
			}
			if ((Object)(object)_image != (Object)null)
			{
				Object.Destroy((Object)(object)_image);
			}
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		private void Update()
		{
			if (!_itemNameRegistered)
			{
				_itemNameRegistered = TryRegisterItemName();
			}
			if (!NetworkClient.active || !NetworkClient.ready)
			{
				_announcedInventory = null;
				return;
			}
			PlayerInventory localPlayerInventory = GameManager.LocalPlayerInventory;
			if (!((Object)(object)localPlayerInventory == (Object)null) && NightWolfHawkRules.ShouldRequestStartingItem(GrantStartingItem.Value, (Object)(object)localPlayerInventory == (Object)(object)_announcedInventory))
			{
				_announcedInventory = localPlayerInventory;
				NetworkClient.Send<NightWolfHawkReadyMessage>(default(NightWolfHawkReadyMessage), 0);
				if (AutoUseWhenAlone.Value && NetworkServer.active && NetworkServer.connections.Count <= 1)
				{
					((MonoBehaviour)this).StartCoroutine(AutoUse(localPlayerInventory));
				}
			}
		}

		private bool TryRegisterItemName()
		{
			//IL_000a: 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_0033: Expected I4, but got Unknown
			try
			{
				StringTable table = ((LocalizedDatabase<StringTable, StringTableEntry>)(object)LocalizationSettings.StringDatabase).GetTable(TableReference.op_Implicit("Data"), (Locale)null);
				if ((Object)(object)table == (Object)null)
				{
					return false;
				}
				((DetailedLocalizationTable<StringTableEntry>)(object)table).AddEntry($"ITEM_{(int)Item}", "Night Wolf Hawk");
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[Night Wolf Hawk] Registered friendly item name 'Night Wolf Hawk'.");
				return true;
			}
			catch
			{
				return false;
			}
		}

		private IEnumerator AutoUse(PlayerInventory inventory)
		{
			yield return (object)new WaitForSecondsRealtime(1f);
			IList<InventorySlot> list = (IList<InventorySlot>)AccessTools.Field(typeof(PlayerInventory), "slots").GetValue(inventory);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].itemType == Item)
				{
					NetworkClient.Send<NightWolfHawkUseRequest>(new NightWolfHawkUseRequest
					{
						SlotIndex = i
					}, 0);
					((BaseUnityPlugin)this).Logger.LogInfo((object)"[Night Wolf Hawk] Solo auto-use test requested.");
					yield break;
				}
			}
			((BaseUnityPlugin)this).Logger.LogWarning((object)"[Night Wolf Hawk] Solo auto-use could not find the item.");
		}

		private string ChooseSoundFileName()
		{
			if (_sounds.Count != 0)
			{
				return Path.GetFileName(_sounds[Random.Range(0, _sounds.Count)]);
			}
			return string.Empty;
		}

		internal void ShowDistraction(string soundFileName)
		{
			string text = _sounds.Find((string path) => string.Equals(Path.GetFileName(path), soundFileName, StringComparison.OrdinalIgnoreCase));
			float num = 0f;
			if (text != null)
			{
				num = PlaySound(text);
			}
			else if (!string.IsNullOrEmpty(soundFileName))
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("[Night Wolf Hawk] Server selected missing sound " + soundFileName + "."));
			}
			_screenEdge = (ScreenEdge)Random.Range(0, 4);
			_distractionStartedAt = Time.unscaledTime;
			_distractionDuration = Mathf.Max(3.5f, num + 0.55f);
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"[Night Wolf Hawk] Opponent distraction shown from {_screenEdge} using {soundFileName}.");
		}

		private float PlaySound(string path)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0046: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			System coreSystem = RuntimeManager.CoreSystem;
			Sound val2 = default(Sound);
			RESULT val = ((System)(ref coreSystem)).createSound(path, (MODE)16392, ref val2);
			if ((int)val != 0)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)$"[Night Wolf Hawk] FMOD could not open {Path.GetFileName(path)}: {val}.");
				return 0f;
			}
			uint num = default(uint);
			((Sound)(ref val2)).getLength(ref num, (TIMEUNIT)1);
			coreSystem = RuntimeManager.CoreSystem;
			Channel channel = default(Channel);
			val = ((System)(ref coreSystem)).playSound(val2, default(ChannelGroup), true, ref channel);
			if ((int)val != 0)
			{
				((Sound)(ref val2)).release();
				((BaseUnityPlugin)this).Logger.LogWarning((object)$"[Night Wolf Hawk] FMOD could not play {Path.GetFileName(path)}: {val}.");
				return 0f;
			}
			((Channel)(ref channel)).setVolume(GetGameSfxVolume());
			((Channel)(ref channel)).setPaused(false);
			float num2 = (float)num / 1000f;
			((MonoBehaviour)this).StartCoroutine(MaintainSound(val2, channel, num2 + 0.25f));
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"[Night Wolf Hawk] FMOD playing {Path.GetFileName(path)} ({num2:0.0}s).");
			return num2;
		}

		private static float GetGameSfxVolume()
		{
			return Mathf.Clamp01(GameSettings.All.Audio.MasterVolume * GameSettings.All.Audio.SfxVolume);
		}

		private static IEnumerator MaintainSound(Sound sound, Channel channel, float duration)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_000f: Unknown result type (might be due to invalid IL or missing references)
			float endTime = Time.unscaledTime + duration;
			while (Time.unscaledTime < endTime)
			{
				((Channel)(ref channel)).setVolume(GetGameSfxVolume());
				yield return null;
			}
			((Sound)(ref sound)).release();
		}

		private void OnGUI()
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: 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_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_image == (Object)null)
			{
				return;
			}
			float num = Time.unscaledTime - _distractionStartedAt;
			if (!(num < 0f) && !(num >= _distractionDuration))
			{
				float num2 = Mathf.Min(340f, (float)Screen.width * 0.22f);
				float num3 = num2 * (float)((Texture)_image).height / (float)((Texture)_image).width;
				float progress = 1f;
				if (num < 0.45f)
				{
					progress = Mathf.SmoothStep(0f, 1f, num / 0.45f);
				}
				else if (num > _distractionDuration - 0.55f)
				{
					progress = 1f - Mathf.SmoothStep(0f, 1f, (num - (_distractionDuration - 0.55f)) / 0.55f);
				}
				Vector2 imageCenter = GetImageCenter(_screenEdge, progress, num2, num3);
				float num4 = _screenEdge switch
				{
					ScreenEdge.Top => 180f, 
					ScreenEdge.Left => 90f, 
					ScreenEdge.Right => -90f, 
					_ => 0f, 
				};
				float num5 = 1f + 0.035f * Mathf.Abs(Mathf.Sin(num * 8f));
				float num6 = num4 + 1.75f * Mathf.Sin(num * 11f);
				num2 *= num5;
				num3 *= num5;
				Matrix4x4 matrix = GUI.matrix;
				GUIUtility.RotateAroundPivot(num6, imageCenter);
				GUI.DrawTexture(new Rect(imageCenter.x - num2 / 2f, imageCenter.y - num3 / 2f, num2, num3), (Texture)(object)_image, (ScaleMode)2, true);
				GUI.matrix = matrix;
			}
		}

		private static Vector2 GetImageCenter(ScreenEdge edge, float progress, float width, float height)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			return (Vector2)(edge switch
			{
				ScreenEdge.Top => new Vector2((float)Screen.width - width / 2f - 18f, Mathf.Lerp((0f - height) / 2f, height / 2f - 36f, progress)), 
				ScreenEdge.Left => new Vector2(Mathf.Lerp((0f - height) / 2f, height / 2f - 36f, progress), (float)Screen.height - width / 2f - 18f), 
				ScreenEdge.Right => new Vector2(Mathf.Lerp((float)Screen.width + height / 2f, (float)Screen.width - height / 2f + 36f, progress), (float)Screen.height - width / 2f - 18f), 
				_ => new Vector2((float)Screen.width - width / 2f - 18f, Mathf.Lerp((float)Screen.height + height / 2f, (float)Screen.height - height / 2f + 36f, progress)), 
			});
		}

		private void LoadImage()
		{
			//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_0045: 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_0058: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			string text = Path.Combine(AssetDirectory, "night-wolf-hawk-person.png");
			if (!File.Exists(text))
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("[Night Wolf Hawk] Missing image: " + text));
				return;
			}
			_image = new Texture2D(2, 2, (TextureFormat)4, false)
			{
				name = "Night Wolf Hawk",
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			if (!ImageConversion.LoadImage(_image, File.ReadAllBytes(text), true))
			{
				Object.Destroy((Object)(object)_image);
				_image = null;
				((BaseUnityPlugin)this).Logger.LogError((object)("[Night Wolf Hawk] Could not decode image: " + text));
			}
			else
			{
				_icon = Sprite.Create(_image, new Rect(0f, 0f, (float)((Texture)_image).width, (float)((Texture)_image).height), new Vector2(0.5f, 0.5f), 100f);
				((Object)_icon).name = "Night Wolf Hawk Inventory Icon";
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"[Night Wolf Hawk] Loaded image {((Texture)_image).width}x{((Texture)_image).height}.");
			}
		}

		private void LoadSounds()
		{
			if (Directory.Exists(AssetDirectory))
			{
				string[] files = Directory.GetFiles(AssetDirectory, "*.mp3");
				foreach (string item in files)
				{
					_sounds.Add(item);
				}
				if (_sounds.Count == 0)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"[Night Wolf Hawk] No MP3 sounds were found.");
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)$"[Night Wolf Hawk] Found {_sounds.Count} MP3 sound(s).");
				}
			}
		}

		private static void RegisterNetworkMessages()
		{
			Writer<NightWolfHawkReadyMessage>.write = delegate
			{
			};
			Reader<NightWolfHawkReadyMessage>.read = (NetworkReader _) => default(NightWolfHawkReadyMessage);
			Writer<NightWolfHawkUseRequest>.write = delegate(NetworkWriter writer, NightWolfHawkUseRequest message)
			{
				NetworkWriterExtensions.WriteInt(writer, message.SlotIndex);
			};
			Reader<NightWolfHawkUseRequest>.read = (NetworkReader reader) => new NightWolfHawkUseRequest
			{
				SlotIndex = NetworkReaderExtensions.ReadInt(reader)
			};
			Writer<NightWolfHawkDistractionMessage>.write = delegate(NetworkWriter writer, NightWolfHawkDistractionMessage message)
			{
				NetworkWriterExtensions.WriteString(writer, message.SoundFileName);
			};
			Reader<NightWolfHawkDistractionMessage>.read = (NetworkReader reader) => new NightWolfHawkDistractionMessage
			{
				SoundFileName = NetworkReaderExtensions.ReadString(reader)
			};
			NetworkClient.RegisterHandler<NightWolfHawkDistractionMessage>((Action<NightWolfHawkDistractionMessage>)delegate(NightWolfHawkDistractionMessage message)
			{
				Instance?.ShowDistraction(message.SoundFileName);
			}, true);
			if (NetworkServer.active)
			{
				NetworkServer.RegisterHandler<NightWolfHawkReadyMessage>((Action<NetworkConnectionToClient, NightWolfHawkReadyMessage>)ServerGrantItem, true);
				NetworkServer.RegisterHandler<NightWolfHawkUseRequest>((Action<NetworkConnectionToClient, NightWolfHawkUseRequest>)ServerUseItem, true);
			}
			Log.LogInfo((object)"[Night Wolf Hawk] Network messages registered.");
		}

		private static void ServerGrantItem(NetworkConnectionToClient connection, NightWolfHawkReadyMessage _)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			NetworkIdentity identity = ((NetworkConnection)connection).identity;
			PlayerInventory val = ((identity != null) ? ((Component)identity).GetComponent<PlayerInventory>() : null);
			if ((Object)(object)val == (Object)null)
			{
				Log.LogWarning((object)"[Night Wolf Hawk] Could not find the joining player's inventory.");
			}
			else
			{
				Log.LogInfo((object)(val.ServerTryAddItem(Item, 1) ? "[Night Wolf Hawk] Added to a player's starting inventory." : "[Night Wolf Hawk] A player's inventory was full."));
			}
		}

		private static void ServerUseItem(NetworkConnectionToClient sender, NightWolfHawkUseRequest message)
		{
			//IL_005b: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			NetworkIdentity identity = ((NetworkConnection)sender).identity;
			PlayerInventory val = ((identity != null) ? ((Component)identity).GetComponent<PlayerInventory>() : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			IList<InventorySlot> list = (IList<InventorySlot>)AccessTools.Field(typeof(PlayerInventory), "slots").GetValue(val);
			if (message.SlotIndex < 0 || message.SlotIndex >= list.Count || list[message.SlotIndex].itemType != Item)
			{
				Log.LogWarning((object)"[Night Wolf Hawk] Rejected an invalid use request.");
				return;
			}
			bool flag = NightWolfHawkRules.ShouldConsumeItem(NetworkServer.connections.Count, InfiniteUsesWhenAlone.Value);
			if (flag)
			{
				list[message.SlotIndex] = InventorySlot.Empty;
			}
			string text = Instance?.ChooseSoundFileName() ?? string.Empty;
			NightWolfHawkDistractionMessage nightWolfHawkDistractionMessage = new NightWolfHawkDistractionMessage
			{
				SoundFileName = text
			};
			int num = 0;
			foreach (NetworkConnectionToClient value in NetworkServer.connections.Values)
			{
				if (value != null && NightWolfHawkRules.ShouldDistractRecipient(value == sender, ((NetworkConnection)value).isReady))
				{
					((NetworkConnection)value).Send<NightWolfHawkDistractionMessage>(nightWolfHawkDistractionMessage, 0);
					num++;
				}
			}
			bool flag2 = NightWolfHawkRules.ShouldSelfTarget(num, SelfTargetWhenAlone.Value);
			if (flag2)
			{
				((NetworkConnection)sender).Send<NightWolfHawkDistractionMessage>(nightWolfHawkDistractionMessage, 0);
			}
			Log.LogInfo((object)$"[Night Wolf Hawk] Used {text}; distracted {num} opponent(s); solo self-test={flag2}; item consumed={flag}.");
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct NightWolfHawkReadyMessage : NetworkMessage
	{
	}
	public struct NightWolfHawkUseRequest : NetworkMessage
	{
		public int SlotIndex;
	}
	public struct NightWolfHawkDistractionMessage : NetworkMessage
	{
		public string SoundFileName;
	}
}