using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text.Json;
using System.Text.Json.Serialization;
using BepInEx;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BoosterImplants;
using BoosterPack.Manager;
using BoosterPack.Models;
using BoosterPack.Patches;
using CellMenu;
using DropServer.BoosterImplants;
using GameData;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Threading.Tasks;
using Localization;
using MTFO.API;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("BoosterPack")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+git465baee-dirty-master")]
[assembly: AssemblyProduct("BoosterPack")]
[assembly: AssemblyTitle("BoosterPack")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace BoosterPack
{
	[BepInPlugin("Endskill.CustomBoosters", "CustomBoosters", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class BepinExLoader : BasePlugin
	{
		public const string MODNAME = "CustomBoosters";

		public const string AUTHOR = "Endskill";

		public const string GUID = "Endskill.CustomBoosters";

		public const string VERSION = "1.0.0";

		public override void Load()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			LogManager.SetLogger(((BasePlugin)this).Log);
			LogManager._debugMessagesActive = ((BasePlugin)this).Config.Bind<bool>("Dev Settings", "DebugMessages", false, "This settings activates/deactivates debug messages in the console for this specific plugin.").Value;
			Harmony val = new Harmony("Endskill.CustomBoosters");
			val.PatchAll(typeof(PersistentInventoryManagerPatches));
			val.PatchAll(typeof(DropServerPatches));
			val.PatchAll(typeof(BoosterImplantInventoryItemPatches));
			val.PatchAll(typeof(CmPageLoadoutPatches));
			MTFOHotReloadAPI.OnHotReload += ScriptManager.HotReaload;
		}
	}
	public static class CacheApiWrapper
	{
		internal static BoosterImplantPlayerData _inv;

		public static bool UseCustomData { get; set; }

		public static BoosterImplantPlayerData Inventory
		{
			get
			{
				return _inv;
			}
			set
			{
				_inv = value;
			}
		}
	}
	internal static class LogManager
	{
		private static ManualLogSource logger;

		internal static bool _debugMessagesActive;

		internal static void SetLogger(ManualLogSource log)
		{
			logger = log;
		}

		public static void Verbose(object msg)
		{
			if (_debugMessagesActive)
			{
				logger.LogInfo(msg);
			}
		}

		public static void Debug(object msg)
		{
			if (_debugMessagesActive)
			{
				logger.LogDebug(msg);
			}
		}

		public static void Message(object msg)
		{
			if (_debugMessagesActive)
			{
				logger.LogMessage(msg);
			}
		}

		public static void Error(object msg)
		{
			logger.LogError(msg);
		}

		public static void Warn(object msg)
		{
			logger.LogWarning(msg);
		}
	}
	[GeneratedCode("VersionInfoGenerator", "2.0.0+git50a4b1a-master")]
	[CompilerGenerated]
	internal static class VersionInfo
	{
		public const string RootNamespace = "BoosterPack";

		public const string Version = "1.0.0";

		public const string VersionPrerelease = null;

		public const string VersionMetadata = "git465baee-dirty-master";

		public const string SemVer = "1.0.0+git465baee-dirty-master";

		public const string GitRevShort = "465baee-dirty";

		public const string GitRevLong = "465baeed0cd33374f3d2e30104b8e8fe99e66f59-dirty";

		public const string GitBranch = "master";

		public const string GitTag = null;

		public const bool GitIsDirty = true;
	}
}
namespace BoosterPack.Patches
{
	[HarmonyPatch(typeof(BoosterImplantInventoryItem))]
	public class BoosterImplantInventoryItemPatches
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		public static bool Prefix(ref bool __result)
		{
			__result = true;
			return false;
		}
	}
	[HarmonyPatch(typeof(CM_PageLoadout))]
	public static class CmPageLoadoutPatches
	{
		[HarmonyPatch("ProcessBoosterImplantEvents")]
		[HarmonyPrefix]
		public static bool ProcessBoosterImplantEventsPrefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(DropServerManager))]
	public static class DropServerManagerPatches
	{
		private static PlayerInventoryData _cachedInventory;

		[HarmonyPatch("GetBoosterImplantPlayerDataAsync")]
		[HarmonyPrefix]
		public static bool GetBoosterImplantPlayerDataAsyncPrefix(ref Task<PlayerInventoryData> __result)
		{
			LogManager.Debug("Booster Patch");
			__result = GetInventory();
			return false;
		}

		[HarmonyPatch("GetInventoryPlayerDataAsync")]
		[HarmonyPrefix]
		public static bool GetInventoryPlayerDataAsyncPrefix(ref Task<PlayerInventoryData> __result)
		{
			LogManager.Debug("Inventar Patch");
			__result = GetInventory();
			return false;
		}

		private static Task<PlayerInventoryData> GetInventory()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_003b: 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_0046: Expected O, but got Unknown
			//IL_0047: 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_0052: Expected O, but got Unknown
			//IL_0058: Expected O, but got Unknown
			if (_cachedInventory != null)
			{
				return Task.FromResult<PlayerInventoryData>(_cachedInventory);
			}
			_cachedInventory = new PlayerInventoryData();
			_cachedInventory.BoosterData = new Nullable<BoosterImplantPlayerData>(new BoosterImplantPlayerData
			{
				Basic = new Category(),
				Advanced = new Category(),
				Specialized = new Category()
			});
			return Task.FromResult<PlayerInventoryData>(_cachedInventory);
		}
	}
	[HarmonyPatch(typeof(DropServerGameSession))]
	internal class DropServerPatches
	{
		[HarmonyPatch("ConsumeBoosters")]
		[HarmonyPrefix]
		public static bool ConsumeBoostersPrefix()
		{
			return false;
		}
	}
	[HarmonyPatch(typeof(PersistentInventoryManager))]
	public class PersistentInventoryManagerPatches
	{
		private static uint _id = 9599u;

		[HarmonyPatch("UpdateBoosterImplants")]
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		public static bool UpdateBoosterImplantsPrefix(PersistentInventoryManager __instance)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			ScriptManager.Initialize();
			if (!CacheApiWrapper.UseCustomData)
			{
				CreateData();
			}
			BoosterImplant[] array = ((IEnumerable<BoosterImplantCategory>)BoosterImplantConstants.Categories).Select((BoosterImplantCategory c) => PersistentInventoryManager.GetActiveBoosterImplant((BoosterImplantCategory)c)).ToArray();
			UpdateBoosterImplantInventoryModelMock(__instance);
			if ((int)__instance.m_boosterImplantDirtyState == 0)
			{
				__instance.ClearPendingBoosterImplantTransactions();
			}
			else
			{
				PersistentInventoryManager.CleanupPendingBoosterImplantTransactions(__instance.m_boosterImplantPendingTransactions, __instance.m_boosterImplantInventory);
				PersistentInventoryManager.ApplyPendingBoosterImplantTransactionsToModel(__instance.m_boosterImplantInventory, __instance.m_boosterImplantPendingTransactions);
			}
			for (int i = 0; i < array.Length; i++)
			{
				if (PersistentInventoryManager.GetActiveBoosterImplant((BoosterImplantCategory)i) != array[i])
				{
					Action onActiveBoosterImplantsChanged = __instance.OnActiveBoosterImplantsChanged;
					if (onActiveBoosterImplantsChanged != null)
					{
						onActiveBoosterImplantsChanged.Invoke();
					}
					break;
				}
			}
			Action onBoosterImplantInventoryChanged = __instance.OnBoosterImplantInventoryChanged;
			if ((Delegate)(object)onBoosterImplantInventoryChanged == (Delegate)null)
			{
				return false;
			}
			onBoosterImplantInventoryChanged.Invoke();
			return false;
		}

		private static void CreateData()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Expected O, but got Unknown
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Expected O, but got Unknown
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Expected O, but got Unknown
			//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Expected I4, but got Unknown
			Il2CppArrayBase<BoosterImplantTemplateDataBlock> allBlocks = GameDataBlockBase<BoosterImplantTemplateDataBlock>.GetAllBlocks();
			Il2CppArrayBase<BoosterImplantEffectDataBlock> allBlocks2 = GameDataBlockBase<BoosterImplantEffectDataBlock>.GetAllBlocks();
			Il2CppArrayBase<BoosterImplantConditionDataBlock> allBlocks3 = GameDataBlockBase<BoosterImplantConditionDataBlock>.GetAllBlocks();
			List<BoosterImplantInventoryItem> list = new List<BoosterImplantInventoryItem>();
			List<BoosterImplantInventoryItem> list2 = new List<BoosterImplantInventoryItem>();
			List<BoosterImplantInventoryItem> list3 = new List<BoosterImplantInventoryItem>();
			foreach (BoosterImplantTemplateDataBlock item3 in allBlocks)
			{
				BoosterImplantInventoryItem val = new BoosterImplantInventoryItem();
				((BoosterImplantBase)val).Id = _id++;
				((BoosterImplantBase)val).TemplateId = ((GameDataBlockBase<BoosterImplantTemplateDataBlock>)(object)item3).persistentID;
				((BoosterImplantBase)val).UsesRemaining = 88;
				List<BoosterImplantEffect> list4 = new List<BoosterImplantEffect>();
				Enumerator<BoosterImplantEffectInstance> enumerator2 = item3.Effects.GetEnumerator();
				while (enumerator2.MoveNext())
				{
					BoosterImplantEffectInstance effect2 = enumerator2.Current;
					BoosterImplantEffectDataBlock val2 = ((IEnumerable<BoosterImplantEffectDataBlock>)allBlocks2).First((BoosterImplantEffectDataBlock x) => ((GameDataBlockBase<BoosterImplantEffectDataBlock>)(object)x).persistentID == effect2.BoosterImplantEffect);
					LogManager.Debug($"Effect has: {val2.BoosterEffectCategory}, Param: {effect2.MaxValue}");
					BoosterImplantEffect item = default(BoosterImplantEffect);
					item.Id = effect2.BoosterImplantEffect;
					item.Param = effect2.MaxValue;
					list4.Add(item);
				}
				bool flag = true;
				Enumerator<List<BoosterImplantEffectInstance>> enumerator3 = item3.RandomEffects.GetEnumerator();
				while (enumerator3.MoveNext())
				{
					List<BoosterImplantEffectInstance> current2 = enumerator3.Current;
					if (!flag)
					{
						continue;
					}
					flag = false;
					Enumerator<BoosterImplantEffectInstance> enumerator4 = current2.GetEnumerator();
					while (enumerator4.MoveNext())
					{
						BoosterImplantEffectInstance effect = enumerator4.Current;
						BoosterImplantEffectDataBlock val3 = ((IEnumerable<BoosterImplantEffectDataBlock>)allBlocks2).First((BoosterImplantEffectDataBlock x) => ((GameDataBlockBase<BoosterImplantEffectDataBlock>)(object)x).persistentID == effect.BoosterImplantEffect);
						LogManager.Debug($"Effect has: {val3.BoosterEffectCategory}, Param: {effect.MaxValue}");
						BoosterImplantEffect item2 = default(BoosterImplantEffect);
						item2.Id = effect.BoosterImplantEffect;
						item2.Param = effect.MaxValue;
						list4.Add(item2);
					}
				}
				((BoosterImplantBase)val).Effects = Il2CppStructArray<BoosterImplantEffect>.op_Implicit(list4.ToArray());
				foreach (BoosterImplantEffect item4 in (Il2CppArrayBase<BoosterImplantEffect>)(object)((BoosterImplantBase)val).Effects)
				{
					LogManager.Debug($"Effect2 has: {item4.Id}, Param: {item4.Param}");
				}
				((BoosterImplantBase)val).Conditions = new Il2CppStructArray<uint>(Il2CppArrayBase<uint>.op_Implicit(item3.Conditions?.ToArray()));
				BoosterImplantCategory implantCategory = item3.ImplantCategory;
				BoosterImplantCategory val4 = implantCategory;
				switch ((int)val4)
				{
				case 0:
					list.Add(val);
					break;
				case 1:
					list2.Add(val);
					break;
				case 2:
					list3.Add(val);
					break;
				}
			}
			Category val5 = new Category();
			Category val6 = new Category();
			Category val7 = new Category();
			val5.Inventory = new Il2CppReferenceArray<BoosterImplantInventoryItem>(list.ToArray());
			val6.Inventory = new Il2CppReferenceArray<BoosterImplantInventoryItem>(list2.ToArray());
			val7.Inventory = new Il2CppReferenceArray<BoosterImplantInventoryItem>(list3.ToArray());
			BoosterImplantPlayerData val8 = new BoosterImplantPlayerData();
			val8.Basic = val5;
			val8.Advanced = val6;
			val8.Specialized = val7;
			val8.New = Il2CppStructArray<uint>.op_Implicit(new uint[0]);
			CacheApiWrapper.Inventory = val8;
		}

		private static void UpdateBoosterImplantInventoryModelMock(PersistentInventoryManager instance)
		{
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Expected O, but got Unknown
			BoosterImplantPlayerData inventory = CacheApiWrapper.Inventory;
			BoosterImplantInventoryModel boosterImplantInventory = instance.m_boosterImplantInventory;
			boosterImplantInventory.New.Clear();
			int num = 0;
			while (true)
			{
				int num2 = num;
				uint[] array = Il2CppArrayBase<uint>.op_Implicit((Il2CppArrayBase<uint>)(object)inventory.New);
				int num3 = ((array != null) ? array.Length : 0);
				if (num2 < num3)
				{
					boosterImplantInventory.New.Add(((Il2CppArrayBase<uint>)(object)inventory.New)[num]);
					num++;
					continue;
				}
				break;
			}
			Category[] array2 = (Category[])(object)new Category[3] { inventory.Basic, inventory.Advanced, inventory.Specialized };
			int num4 = default(int);
			for (int i = 0; i < array2.Length; i++)
			{
				Category val = array2[i];
				Category val2 = ((Il2CppArrayBase<Category>)(object)boosterImplantInventory.Categories)[i];
				uint num5 = (boosterImplantInventory.FindPrepared((BoosterImplantCategory)i, ref num4) ? ((Il2CppArrayBase<Category>)(object)boosterImplantInventory.Categories)[i].Inventory[num4].InstanceId : uint.MaxValue);
				val2.Inventory.Clear();
				for (int j = 0; j < ((Il2CppArrayBase<BoosterImplantInventoryItem>)(object)val.Inventory).Length; j++)
				{
					try
					{
						BoosterImplantInventoryItem val3 = ((Il2CppArrayBase<BoosterImplantInventoryItem>)(object)val.Inventory)[j];
						foreach (BoosterImplantEffect item in (Il2CppArrayBase<BoosterImplantEffect>)(object)((BoosterImplantBase)val3).Effects)
						{
							LogManager.Debug($"testItem has: {item.Id} {item.Param}");
						}
						BoosterImplantInventoryItem val4 = new BoosterImplantInventoryItem(((Il2CppArrayBase<BoosterImplantInventoryItem>)(object)val.Inventory)[j]);
						val4.Prepared = val4.InstanceId == num5;
						val2.Inventory.Add(val4);
					}
					catch (Exception ex)
					{
						PersistentInventoryManager.LogError(ex.Message);
					}
				}
				val2.Currency = val.Currency;
				val2.Missed = val.Missed;
				val2.MissedAcknowledged = Mathf.Clamp(val2.MissedAcknowledged, val.MissedAck, val.Missed);
			}
		}
	}
}
namespace BoosterPack.Models
{
	public class ActivateableBoosterData
	{
		public bool UseCustomData { get; set; }

		public List<CustomBooster> CustomBoosters { get; set; }
	}
	public class CustomBooster
	{
		private List<CustomEffect> _effects;

		private List<CustomCondition> _conditions;

		public string PublicName { get; set; }

		public string Description { get; set; }

		public BoosterEffectCategory MainEffectType { get; set; }

		public BoosterImplantCategory ImplantCategory { get; set; }

		public List<CustomEffect> Effects
		{
			get
			{
				if (_effects == null)
				{
					_effects = new List<CustomEffect>();
				}
				return _effects;
			}
			set
			{
				_effects = value;
			}
		}

		public List<CustomCondition> Conditions
		{
			get
			{
				if (_conditions == null)
				{
					_conditions = new List<CustomCondition>();
				}
				return _conditions;
			}
			set
			{
				_conditions = value;
			}
		}
	}
	public class CustomCondition
	{
		public BoosterCondition Condition { get; set; }

		public string PublicShortName { get; set; }

		public string PublicName { get; set; }

		public string Description { get; set; }
	}
	public class CustomEffect
	{
		public AgentModifier Effect { get; set; }

		public string PublicShortName { get; set; }

		public string PublicName { get; set; }

		public string Description { get; set; }

		public string DescriptionNegative { get; set; }

		public BoosterEffectCategory EffectCategory { get; set; }

		public float Value { get; set; }
	}
}
namespace BoosterPack.Manager
{
	public class DataBlockManager
	{
		private uint _templateIds = 306783378u;

		private uint _effectIds = 306783378u;

		private uint _conditionIds = 306783378u;

		private uint _itemId = 306783378u;

		private uint _id = 536870911u;

		public List<BoosterImplantInventoryItem> Basic { get; }

		public List<BoosterImplantInventoryItem> Advanced { get; }

		public List<BoosterImplantInventoryItem> Special { get; }

		public DataBlockManager()
		{
			Basic = new List<BoosterImplantInventoryItem>();
			Advanced = new List<BoosterImplantInventoryItem>();
			Special = new List<BoosterImplantInventoryItem>();
		}

		public void CreateDataBlocksForBooster(CustomBooster booster)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_005c: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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: Expected O, but got Unknown
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Expected O, but got Unknown
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Expected O, but got Unknown
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Expected I4, but got Unknown
			BoosterImplantTemplateDataBlock val = new BoosterImplantTemplateDataBlock();
			((GameDataBlockBase<BoosterImplantTemplateDataBlock>)(object)val).name = GetUniqueName();
			((GameDataBlockBase<BoosterImplantTemplateDataBlock>)(object)val).persistentID = ++_templateIds;
			val.Deprecated = false;
			val.PublicName = GetTranslation(booster.PublicName);
			val.Description = GetTranslation(booster.Description);
			val.ImplantCategory = booster.ImplantCategory;
			val.MainEffectType = booster.MainEffectType;
			foreach (CustomEffect effect in booster.Effects)
			{
				BoosterImplantEffectDataBlock val2 = new BoosterImplantEffectDataBlock();
				((GameDataBlockBase<BoosterImplantEffectDataBlock>)(object)val2).name = GetUniqueName();
				val2.Effect = effect.Effect;
				val2.BoosterEffectCategory = effect.EffectCategory;
				val2.PublicShortName = GetTranslation(effect.PublicShortName);
				val2.PublicName = GetTranslation(effect.PublicName);
				val2.Description = GetTranslation(effect.Description);
				val2.DescriptionNegative = GetTranslation(effect.DescriptionNegative);
				((GameDataBlockBase<BoosterImplantEffectDataBlock>)(object)val2).persistentID = _effectIds++;
				BoosterImplantEffectInstance val3 = new BoosterImplantEffectInstance();
				val3.BoosterImplantEffect = ((GameDataBlockBase<BoosterImplantEffectDataBlock>)(object)val2).persistentID;
				val3.MinValue = effect.Value;
				val3.MaxValue = effect.Value;
				val.Effects.Add(val3);
				GameDataBlockBase<BoosterImplantEffectDataBlock>.AddBlock(val2, -1);
			}
			foreach (CustomCondition condition in booster.Conditions)
			{
				BoosterImplantConditionDataBlock val4 = new BoosterImplantConditionDataBlock();
				((GameDataBlockBase<BoosterImplantConditionDataBlock>)(object)val4).name = GetUniqueName();
				val4.Condition = condition.Condition;
				val4.PublicShortName = GetTranslation(condition.PublicShortName);
				val4.PublicName = GetTranslation(condition.PublicName);
				val4.Description = GetTranslation(condition.Description);
				((GameDataBlockBase<BoosterImplantConditionDataBlock>)(object)val4).persistentID = _conditionIds++;
				val.Conditions.Add(((GameDataBlockBase<BoosterImplantConditionDataBlock>)(object)val4).persistentID);
				GameDataBlockBase<BoosterImplantConditionDataBlock>.AddBlock(val4, -1);
			}
			GameDataBlockBase<BoosterImplantTemplateDataBlock>.AddBlock(val, -1);
			BoosterImplantInventoryItem val5 = new BoosterImplantInventoryItem();
			((BoosterImplantBase)val5).Id = _itemId++;
			((BoosterImplantBase)val5).TemplateId = ((GameDataBlockBase<BoosterImplantTemplateDataBlock>)(object)val).persistentID;
			((BoosterImplantBase)val5).UsesRemaining = 99;
			List<BoosterImplantEffect> list = new List<BoosterImplantEffect>();
			Enumerator<BoosterImplantEffectInstance> enumerator3 = val.Effects.GetEnumerator();
			while (enumerator3.MoveNext())
			{
				BoosterImplantEffectInstance current3 = enumerator3.Current;
				BoosterImplantEffect item = default(BoosterImplantEffect);
				item.Id = current3.BoosterImplantEffect;
				item.Param = current3.MaxValue;
				list.Add(item);
			}
			((BoosterImplantBase)val5).Effects = Il2CppStructArray<BoosterImplantEffect>.op_Implicit(list.ToArray());
			((BoosterImplantBase)val5).Conditions = new Il2CppStructArray<uint>(Il2CppArrayBase<uint>.op_Implicit(val.Conditions?.ToArray()));
			BoosterImplantCategory implantCategory = val.ImplantCategory;
			BoosterImplantCategory val6 = implantCategory;
			switch ((int)val6)
			{
			case 0:
				Basic.Add(val5);
				break;
			case 1:
				Advanced.Add(val5);
				break;
			case 2:
				Special.Add(val5);
				break;
			}
		}

		private LocalizedText GetTranslation(string booLocalization)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			LocalizedText val = new LocalizedText();
			val.UntranslatedText = booLocalization;
			return val;
		}

		private string GetUniqueName()
		{
			return $"CustomBoosters_{++_id}";
		}
	}
	public static class ScriptManager
	{
		private static bool _initialized;

		internal static void HotReaload()
		{
			_initialized = false;
			Initialize();
			PersistentInventoryManager.Current.UpdateBoosterImplants(ref CacheApiWrapper._inv);
		}

		public static void Initialize()
		{
			if (!_initialized)
			{
				_initialized = true;
				string text = Path.Combine(MTFOPathAPI.CustomPath, "CustomBoosters");
				if (!Directory.Exists(text))
				{
					Directory.CreateDirectory(text);
				}
				WriteEnumValues(text);
				text = Path.Combine(text, "CustomBoosters.json");
				WriteDefault(text);
				ActivateableBoosterData data = ReadData(text);
				PrepareForUseIngame(data);
			}
		}

		public static void PrepareForUseIngame(ActivateableBoosterData data)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			CacheApiWrapper.UseCustomData = data.UseCustomData;
			List<CustomBooster> customBoosters = data.CustomBoosters;
			DataBlockManager dataBlockManager = new DataBlockManager();
			foreach (CustomBooster item in customBoosters)
			{
				dataBlockManager.CreateDataBlocksForBooster(item);
			}
			Category val = new Category();
			Category val2 = new Category();
			Category val3 = new Category();
			val.Inventory = Il2CppReferenceArray<BoosterImplantInventoryItem>.op_Implicit(dataBlockManager.Basic.ToArray());
			val2.Inventory = Il2CppReferenceArray<BoosterImplantInventoryItem>.op_Implicit(dataBlockManager.Advanced.ToArray());
			val3.Inventory = Il2CppReferenceArray<BoosterImplantInventoryItem>.op_Implicit(dataBlockManager.Special.ToArray());
			BoosterImplantPlayerData val4 = new BoosterImplantPlayerData();
			val4.Basic = val;
			val4.Advanced = val2;
			val4.Specialized = val3;
			val4.New = Il2CppStructArray<uint>.op_Implicit(new uint[0]);
			CacheApiWrapper.Inventory = val4;
		}

		private static ActivateableBoosterData ReadData(string path)
		{
			JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions
			{
				IncludeFields = false,
				ReadCommentHandling = JsonCommentHandling.Skip,
				PropertyNameCaseInsensitive = true,
				WriteIndented = true
			};
			jsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
			return JsonSerializer.Deserialize<ActivateableBoosterData>(File.ReadAllText(path), jsonSerializerOptions) ?? ParseExistingDataBlocks();
		}

		private static void WriteDefault(string path)
		{
			if (!File.Exists(path))
			{
				JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions
				{
					IncludeFields = false,
					ReadCommentHandling = JsonCommentHandling.Skip,
					PropertyNameCaseInsensitive = true,
					WriteIndented = true
				};
				jsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
				File.WriteAllText(path, JsonSerializer.Serialize(ParseExistingDataBlocks(), jsonSerializerOptions));
			}
		}

		private static void WriteEnumValues(string dictionaryPath)
		{
			string path = Path.Combine(dictionaryPath, "MainEffectType.txt");
			if (!File.Exists(path))
			{
				File.WriteAllText(path, "==This file is auto-generated by CustomBoosters. It's not for editing==\n" + string.Join("\n", Enum.GetNames(typeof(BoosterEffectCategory))));
			}
			string path2 = Path.Combine(dictionaryPath, "EffectCategory.txt");
			if (!File.Exists(path2))
			{
				File.WriteAllText(path2, "==This file is auto-generated by CustomBoosters. It's not for editing==\n" + string.Join("\n", Enum.GetNames(typeof(BoosterEffectCategory))));
			}
			string path3 = Path.Combine(dictionaryPath, "ImplantCategory.txt");
			if (!File.Exists(path3))
			{
				File.WriteAllText(path3, "==This file is auto-generated by CustomBoosters. It's not for editing==\n" + string.Join("\n", Enum.GetNames(typeof(BoosterImplantCategory))));
			}
			string path4 = Path.Combine(dictionaryPath, "Effect.txt");
			if (!File.Exists(path4))
			{
				File.WriteAllText(path4, "==This file is auto-generated by CustomBoosters. It's not for editing==\n" + string.Join("\n", Enum.GetNames(typeof(AgentModifier))));
			}
			string path5 = Path.Combine(dictionaryPath, "Condition.txt");
			if (!File.Exists(path5))
			{
				File.WriteAllText(path5, "==This file is auto-generated by CustomBoosters. It's not for editing==\n" + string.Join("\n", Enum.GetNames(typeof(BoosterCondition))));
			}
		}

		private static ActivateableBoosterData ParseExistingDataBlocks()
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			ActivateableBoosterData activateableBoosterData = new ActivateableBoosterData();
			List<CustomBooster> list2 = (activateableBoosterData.CustomBoosters = new List<CustomBooster>());
			activateableBoosterData.UseCustomData = false;
			Il2CppArrayBase<BoosterImplantTemplateDataBlock> allBlocks = GameDataBlockBase<BoosterImplantTemplateDataBlock>.GetAllBlocks();
			Il2CppArrayBase<BoosterImplantEffectDataBlock> allBlocks2 = GameDataBlockBase<BoosterImplantEffectDataBlock>.GetAllBlocks();
			Il2CppArrayBase<BoosterImplantConditionDataBlock> allBlocks3 = GameDataBlockBase<BoosterImplantConditionDataBlock>.GetAllBlocks();
			foreach (BoosterImplantTemplateDataBlock temp in allBlocks)
			{
				CustomBooster customBooster = new CustomBooster();
				customBooster.PublicName = Text.Get(temp.PublicName.Id);
				customBooster.Description = Text.Get(temp.Description.Id);
				customBooster.MainEffectType = temp.MainEffectType;
				customBooster.ImplantCategory = temp.ImplantCategory;
				Enumerator<BoosterImplantEffectInstance> enumerator2 = temp.Effects.GetEnumerator();
				while (enumerator2.MoveNext())
				{
					BoosterImplantEffectInstance effect = enumerator2.Current;
					BoosterImplantEffectDataBlock effectDb2 = ((IEnumerable<BoosterImplantEffectDataBlock>)allBlocks2).First((BoosterImplantEffectDataBlock x) => ((GameDataBlockBase<BoosterImplantEffectDataBlock>)(object)x).persistentID == effect.BoosterImplantEffect);
					customBooster.Effects.Add(ParseEffect(effectDb2, effect.MaxValue));
				}
				if (temp.RandomEffects.Count > 0)
				{
					Enumerator<BoosterImplantEffectInstance> enumerator3 = temp.RandomEffects[0].GetEnumerator();
					while (enumerator3.MoveNext())
					{
						BoosterImplantEffectInstance effect2 = enumerator3.Current;
						BoosterImplantEffectDataBlock effectDb3 = ((IEnumerable<BoosterImplantEffectDataBlock>)allBlocks2).First((BoosterImplantEffectDataBlock x) => ((GameDataBlockBase<BoosterImplantEffectDataBlock>)(object)x).persistentID == effect2.BoosterImplantEffect);
						customBooster.Effects.Add(ParseEffect(effectDb3, effect2.MaxValue));
					}
				}
				Enumerator<uint> enumerator4 = temp.Conditions.GetEnumerator();
				while (enumerator4.MoveNext())
				{
					uint condition = enumerator4.Current;
					BoosterImplantConditionDataBlock conditionDb2 = ((IEnumerable<BoosterImplantConditionDataBlock>)allBlocks3).First((BoosterImplantConditionDataBlock x) => ((GameDataBlockBase<BoosterImplantConditionDataBlock>)(object)x).persistentID == condition);
					customBooster.Conditions.Add(ParseCondition(conditionDb2));
				}
				if (temp.RandomConditions.Count > 0)
				{
					BoosterImplantConditionDataBlock conditionDb3 = ((IEnumerable<BoosterImplantConditionDataBlock>)allBlocks3).First((BoosterImplantConditionDataBlock x) => ((GameDataBlockBase<BoosterImplantConditionDataBlock>)(object)x).persistentID == temp.RandomConditions[0]);
					customBooster.Conditions.Add(ParseCondition(conditionDb3));
				}
				list2.Add(customBooster);
			}
			return activateableBoosterData;
			static CustomCondition ParseCondition(BoosterImplantConditionDataBlock conditionDb)
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				return new CustomCondition
				{
					PublicShortName = Text.Get(conditionDb.PublicShortName.Id),
					PublicName = Text.Get(conditionDb.PublicName.Id),
					Description = Text.Get(conditionDb.Description.Id),
					Condition = conditionDb.Condition
				};
			}
			static CustomEffect ParseEffect(BoosterImplantEffectDataBlock effectDb, float value)
			{
				//IL_0065: 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)
				return new CustomEffect
				{
					PublicShortName = Text.Get(effectDb.PublicShortName.Id),
					PublicName = Text.Get(effectDb.PublicName.Id),
					Description = Text.Get(effectDb.Description.Id),
					DescriptionNegative = Text.Get(effectDb.DescriptionNegative.Id),
					Effect = effectDb.Effect,
					EffectCategory = effectDb.BoosterEffectCategory,
					Value = value
				};
			}
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using AK;
using Agents;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Utils.Collections;
using CharacterDestruction;
using EndskApi.Api;
using EndskApi.Enums.EnemyKill;
using EndskApi.Information.EnemyKill;
using Enemies;
using ExtraWeaponCustomization.CustomWeapon;
using ExtraWeaponCustomization.CustomWeapon.KillTracker;
using ExtraWeaponCustomization.CustomWeapon.ObjectWrappers;
using ExtraWeaponCustomization.CustomWeapon.Properties;
using ExtraWeaponCustomization.CustomWeapon.Properties.Effects;
using ExtraWeaponCustomization.CustomWeapon.Properties.Effects.EEC_Explosion;
using ExtraWeaponCustomization.CustomWeapon.Properties.Effects.EEC_Explosion.Handlers;
using ExtraWeaponCustomization.CustomWeapon.Properties.Effects.FireRate;
using ExtraWeaponCustomization.CustomWeapon.Properties.Effects.Heal;
using ExtraWeaponCustomization.CustomWeapon.Properties.Effects.Triggers;
using ExtraWeaponCustomization.CustomWeapon.Properties.Traits;
using ExtraWeaponCustomization.CustomWeapon.Properties.Traits.CustomProjectile.Components;
using ExtraWeaponCustomization.CustomWeapon.Properties.Traits.CustomProjectile.Managers;
using ExtraWeaponCustomization.CustomWeapon.WeaponContext;
using ExtraWeaponCustomization.CustomWeapon.WeaponContext.Contexts;
using ExtraWeaponCustomization.Dependencies;
using ExtraWeaponCustomization.JSON;
using ExtraWeaponCustomization.JSON.Converters;
using ExtraWeaponCustomization.Networking;
using ExtraWeaponCustomization.Networking.Structs;
using ExtraWeaponCustomization.Patches;
using ExtraWeaponCustomization.Utils;
using FX_EffectSystem;
using GTFO.API;
using GTFO.API.JSON.Converters;
using GTFO.API.Utilities;
using GTFuckingXP.Extensions;
using GameData;
using Gear;
using HarmonyLib;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using KillIndicatorFix;
using MTFO.API;
using Microsoft.CodeAnalysis;
using Player;
using SNetwork;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ExtraWeaponCustomization")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f67ed384f3c21e42e4d6acbf3d1ebfdfe8084fa4")]
[assembly: AssemblyProduct("ExtraWeaponCustomization")]
[assembly: AssemblyTitle("ExtraWeaponCustomization")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace ExtraWeaponCustomization
{
	internal static class Configuration
	{
		private static readonly ConfigFile configFile;

		private static ConfigEntry<bool> ForceCreateTemplate { get; set; }

		public static bool ShowExplosionEffect { get; set; }

		public static bool PlayExplosionSFX { get; set; }

		public static float ExplosionSFXCooldown { get; set; }

		public static int ExplosionSFXShotOverride { get; set; }

		static Configuration()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			ShowExplosionEffect = true;
			PlayExplosionSFX = true;
			ExplosionSFXCooldown = 0.08f;
			ExplosionSFXShotOverride = 8;
			configFile = new ConfigFile(Path.Combine(Paths.ConfigPath, "ExtraWeaponCustomization.cfg"), true);
			BindAll(configFile);
		}

		internal static void Init()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			LiveEdit.CreateListener(Paths.ConfigPath, "ExtraWeaponCustomization.cfg", false).FileChanged += new LiveEditEventHandler(OnFileChanged);
		}

		private static void OnFileChanged(LiveEditEventArgs _)
		{
			string text = "Explosion Settings";
			configFile.Reload();
			ShowExplosionEffect = (bool)configFile[text, "Show Effect"].BoxedValue;
			PlayExplosionSFX = (bool)configFile[text, "Play Sound"].BoxedValue;
			ExplosionSFXCooldown = (float)configFile[text, "SFX Cooldown"].BoxedValue;
			ExplosionSFXShotOverride = (int)configFile[text, "Shots to Override SFX Cooldown"].BoxedValue;
			CheckAndRefreshTemplate();
		}

		private static void BindAll(ConfigFile config)
		{
			string text = "Explosion Settings";
			ShowExplosionEffect = config.Bind<bool>(text, "Show Effect", ShowExplosionEffect, "Enables explosion visual FX.").Value;
			PlayExplosionSFX = config.Bind<bool>(text, "Play Sound", PlayExplosionSFX, "Enables explosion sound FX.").Value;
			ExplosionSFXCooldown = config.Bind<float>(text, "SFX Cooldown", ExplosionSFXCooldown, "Minimum cooldown between explosion sound effects, to prevent obnoxiously loud sounds.").Value;
			ExplosionSFXShotOverride = config.Bind<int>(text, "Shots to Override SFX Cooldown", ExplosionSFXShotOverride, "Amount of shots fired before another explosion visual effect is forced, regardless of cooldown.\nSmaller numbers let fast-firing weapons and shotguns spawn more effects in a short span of time.").Value;
			text = "Developer Tools";
			ForceCreateTemplate = config.Bind<bool>(text, "Force Create Template", false, "Creates the template file again.");
			CheckAndRefreshTemplate();
		}

		private static void CheckAndRefreshTemplate()
		{
			if (ForceCreateTemplate.Value)
			{
				ForceCreateTemplate.Value = false;
				CustomWeaponManager.Current.CreateTemplate();
				configFile.Save();
			}
		}
	}
	[BepInPlugin("Dinorush.ExtraWeaponCustomization", "ExtraWeaponCustomization", "1.8.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal sealed class EntryPoint : BasePlugin
	{
		public const string MODNAME = "ExtraWeaponCustomization";

		public override void Load()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			EWCLogger.Log("Loading ExtraWeaponCustomization");
			new Harmony("ExtraWeaponCustomization").PatchAll();
			Configuration.Init();
			LevelAPI.OnLevelCleanup += LevelAPI_OnLevelCleanup;
			AssetAPI.OnStartupAssetsLoaded += AssetAPI_OnStartupAssetsLoaded;
			EWCLogger.Log("Loaded ExtraWeaponCustomization");
		}

		private void LevelAPI_OnLevelCleanup()
		{
			CustomWeaponManager.Current.ResetCWCs();
			EWCProjectileManager.Reset();
		}

		private void AssetAPI_OnStartupAssetsLoaded()
		{
			ClassInjector.RegisterTypeInIl2Cpp<ExplosionEffectHandler>();
			ClassInjector.RegisterTypeInIl2Cpp<CustomWeaponComponent>();
			ClassInjector.RegisterTypeInIl2Cpp<EWCProjectileComponentBase>();
			ClassInjector.RegisterTypeInIl2Cpp<EWCProjectileComponentShooter>();
			ExplosionManager.Init();
			DOTDamageManager.Init();
			HealManager.Init();
			FireRateModManager.Init();
			KillAPIWrapper.Init();
			EWCProjectileManager.Init();
			CustomWeaponManager.Current.GetCustomWeaponData(0u);
		}
	}
}
namespace ExtraWeaponCustomization.Utils
{
	internal static class DamageableUtil
	{
		public static IDamageable? GetDamageableFromData(WeaponHitData data)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return GetDamageableFromRayHit(data.rayHit);
		}

		public static IDamageable? GetDamageableFromCollider(Collider collider)
		{
			GameObject gameObject = ((Component)collider).gameObject;
			if ((Object)(object)gameObject == (Object)null)
			{
				return null;
			}
			ColliderMaterial component = gameObject.GetComponent<ColliderMaterial>();
			IDamageable val = ((component != null) ? component.Damageable : null);
			if (val != null)
			{
				return val;
			}
			return gameObject.GetComponent<IDamageable>();
		}

		public static IDamageable? GetDamageableFromRayHit(RaycastHit rayHit)
		{
			return GetDamageableFromCollider(((RaycastHit)(ref rayHit)).collider);
		}
	}
	internal static class EWCLogger
	{
		private static ManualLogSource logger = Logger.CreateLogSource("ExtraWeaponCustomization");

		public static void Log(string format, params object[] args)
		{
			Log(string.Format(format, args));
		}

		public static void Log(string str)
		{
			if (logger != null)
			{
				logger.Log((LogLevel)8, (object)str);
			}
		}

		public static void Warning(string format, params object[] args)
		{
			Warning(string.Format(format, args));
		}

		public static void Warning(string str)
		{
			if (logger != null)
			{
				logger.Log((LogLevel)4, (object)str);
			}
		}

		public static void Error(string format, params object[] args)
		{
			Error(string.Format(format, args));
		}

		public static void Error(string str)
		{
			if (logger != null)
			{
				logger.Log((LogLevel)2, (object)str);
			}
		}

		public static void Debug(string format, params object[] args)
		{
			Debug(string.Format(format, args));
		}

		public static void Debug(string str)
		{
			if (logger != null)
			{
				logger.Log((LogLevel)32, (object)str);
			}
		}
	}
	internal static class FloatExtensions
	{
		public static float Map(this float orig, float fromMin, float fromMax, float toMin, float toMax)
		{
			if (fromMin == fromMax)
			{
				if (!(orig < fromMin))
				{
					return toMax;
				}
				return toMin;
			}
			orig = Mathf.Clamp(orig, fromMin, fromMax);
			return (orig - fromMin) / (fromMax - fromMin) * (toMax - toMin) + toMin;
		}
	}
	internal static class MTFOPartialDataUtil
	{
		public const string PLUGIN_GUID = "MTFO.Extension.PartialBlocks";

		public static JsonConverter? PersistentIDConverter { get; private set; }

		public static JsonConverter? LocalizedTextConverter { get; private set; }

		public static bool IsLoaded { get; private set; }

		public static bool Initialized { get; private set; }

		public static string PartialDataPath { get; private set; }

		public static string ConfigPath { get; private set; }

		static MTFOPartialDataUtil()
		{
			PersistentIDConverter = null;
			LocalizedTextConverter = null;
			IsLoaded = false;
			Initialized = false;
			PartialDataPath = string.Empty;
			ConfigPath = string.Empty;
			if (!((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.TryGetValue("MTFO.Extension.PartialBlocks", out var value))
			{
				return;
			}
			try
			{
				Assembly obj = ((value == null) ? null : value.Instance?.GetType()?.Assembly) ?? null;
				if ((object)obj == null)
				{
					throw new Exception("Assembly is Missing!");
				}
				Type[] types = obj.GetTypes();
				Type type = types.First((Type t) => t.Name == "PersistentIDConverter");
				if ((object)type == null)
				{
					throw new Exception("Unable to Find PersistentIDConverter Class");
				}
				Type type2 = types.First((Type t) => t.Name == "PartialDataManager");
				if ((object)type2 == null)
				{
					throw new Exception("Unable to Find PartialDataManager Class");
				}
				Type type3 = types.First((Type t) => t.Name == "LocalizedTextConverter") ?? throw new Exception("Unable to Find LocalizedTextConverter Class");
				PropertyInfo property = type2.GetProperty("Initialized", BindingFlags.Static | BindingFlags.Public);
				PropertyInfo property2 = type2.GetProperty("PartialDataPath", BindingFlags.Static | BindingFlags.Public);
				PropertyInfo? property3 = type2.GetProperty("ConfigPath", BindingFlags.Static | BindingFlags.Public);
				if ((object)property == null)
				{
					throw new Exception("Unable to Find Property: Initialized");
				}
				if ((object)property2 == null)
				{
					throw new Exception("Unable to Find Property: PartialDataPath");
				}
				if ((object)property3 == null)
				{
					throw new Exception("Unable to Find Field: ConfigPath");
				}
				Initialized = (bool)property.GetValue(null);
				PartialDataPath = (string)property2.GetValue(null);
				ConfigPath = (string)property3.GetValue(null);
				PersistentIDConverter = (JsonConverter)Activator.CreateInstance(type);
				LocalizedTextConverter = (JsonConverter)Activator.CreateInstance(type3);
				IsLoaded = true;
			}
			catch (Exception value2)
			{
				EWCLogger.Error($"Exception thrown while reading data from MTFO_Extension_PartialData:\n{value2}");
			}
		}
	}
	internal static class MTFOUtil
	{
		public const string PLUGIN_GUID = "com.dak.MTFO";

		public const BindingFlags PUBLIC_STATIC = BindingFlags.Static | BindingFlags.Public;

		public static string GameDataPath { get; private set; }

		public static string CustomPath { get; private set; }

		public static bool HasCustomContent { get; private set; }

		public static bool IsLoaded { get; private set; }

		static MTFOUtil()
		{
			GameDataPath = string.Empty;
			CustomPath = string.Empty;
			HasCustomContent = false;
			IsLoaded = false;
			if (!((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.TryGetValue("com.dak.MTFO", out var value))
			{
				return;
			}
			try
			{
				Assembly obj = ((value == null) ? null : value.Instance?.GetType()?.Assembly) ?? null;
				if ((object)obj == null)
				{
					throw new Exception("Assembly is Missing!");
				}
				Type obj2 = obj.GetTypes().First((Type t) => t.Name == "ConfigManager") ?? throw new Exception("Unable to Find ConfigManager Class");
				FieldInfo field = obj2.GetField("GameDataPath", BindingFlags.Static | BindingFlags.Public);
				FieldInfo field2 = obj2.GetField("CustomPath", BindingFlags.Static | BindingFlags.Public);
				FieldInfo? field3 = obj2.GetField("HasCustomContent", BindingFlags.Static | BindingFlags.Public);
				if ((object)field == null)
				{
					throw new Exception("Unable to Find Field: GameDataPath");
				}
				if ((object)field2 == null)
				{
					throw new Exception("Unable to Find Field: CustomPath");
				}
				if ((object)field3 == null)
				{
					throw new Exception("Unable to Find Field: HasCustomContent");
				}
				GameDataPath = (string)field.GetValue(null);
				CustomPath = (string)field2.GetValue(null);
				HasCustomContent = (bool)field3.GetValue(null);
				IsLoaded = true;
			}
			catch (Exception value2)
			{
				EWCLogger.Log($"Exception thrown while reading path from DataDumper (MTFO): \n{value2}");
			}
		}
	}
	internal static class StringExtensions
	{
		public static T ToEnum<T>(this string? value, T defaultValue) where T : struct
		{
			if (string.IsNullOrEmpty(value))
			{
				return defaultValue;
			}
			if (!Enum.TryParse<T>(value.Replace(" ", null), ignoreCase: true, out var result))
			{
				return defaultValue;
			}
			return result;
		}
	}
	internal static class WeaponHitExtensions
	{
		public static float Falloff(this WeaponHitData data, float additionalDist = 0f)
		{
			//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_0011: 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)
			RaycastHit rayHit = data.rayHit;
			return (((RaycastHit)(ref rayHit)).distance + additionalDist).Map(data.damageFalloff.x, data.damageFalloff.y, 1f, BulletWeapon.s_falloffMin);
		}
	}
}
namespace ExtraWeaponCustomization.Patches
{
	[HarmonyPatch]
	internal static class EnemyLimbPatches
	{
		private static float _cachedArmor;

		[HarmonyPatch(typeof(Dam_EnemyDamageLimb), "BulletDamage")]
		[HarmonyWrapSafe]
		[HarmonyPrefix]
		private static void Pre_BulletDamage(Dam_EnemyDamageLimb __instance)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			CustomWeaponComponent cachedHitCWC = WeaponPatches.CachedHitCWC;
			if (!((Object)(object)cachedHitCWC == (Object)null) && (int)__instance.m_type == 2)
			{
				_cachedArmor = __instance.m_armorDamageMulti;
				WeaponArmorContext weaponArmorContext = new WeaponArmorContext(_cachedArmor, cachedHitCWC.Weapon);
				cachedHitCWC.Invoke(weaponArmorContext);
				__instance.m_armorDamageMulti = weaponArmorContext.ArmorMulti;
			}
		}

		[HarmonyPatch(typeof(Dam_EnemyDamageLimb), "BulletDamage")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void Post_BulletDamage(Dam_EnemyDamageLimb __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			if (!((Object)(object)WeaponPatches.CachedHitCWC == (Object)null) && (int)__instance.m_type == 2)
			{
				__instance.m_armorDamageMulti = _cachedArmor;
			}
		}

		[HarmonyPatch(typeof(Dam_EnemyDamageLimb), "MeleeDamage")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void Post_MeleeDamage(Dam_EnemyDamageLimb __instance, Agent sourceAgent)
		{
			if (sourceAgent.IsLocallyOwned)
			{
				KillTrackerManager.ClearHit(__instance.m_base.Owner);
			}
		}
	}
	[HarmonyPatch]
	internal static class PlayerInventoryPatches
	{
		[HarmonyPatch(typeof(PUI_Inventory), "SetSlotAmmo")]
		[HarmonyWrapSafe]
		[HarmonyPrefix]
		private static void SetAmmoUICallback(PUI_Inventory __instance, InventorySlot slot, ref int clipAbs, ref int inPackAbs, ref float inPackRel)
		{
			//IL_0000: 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)
			if ((int)slot == 0)
			{
				return;
			}
			SNet_Player owner = __instance.m_owner;
			object obj;
			if (owner == null)
			{
				obj = null;
			}
			else
			{
				SNet_IPlayerAgent playerAgent = owner.PlayerAgent;
				if (playerAgent == null)
				{
					obj = null;
				}
				else
				{
					PlayerAgent obj2 = ((Il2CppObjectBase)playerAgent).TryCast<PlayerAgent>();
					if (obj2 == null)
					{
						obj = null;
					}
					else
					{
						FirstPersonItemHolder fPItemHolder = obj2.FPItemHolder;
						if (fPItemHolder == null)
						{
							obj = null;
						}
						else
						{
							ItemEquippable wieldedItem = fPItemHolder.WieldedItem;
							if (wieldedItem == null)
							{
								obj = null;
							}
							else
							{
								BulletWeapon obj3 = ((Il2CppObjectBase)wieldedItem).TryCast<BulletWeapon>();
								obj = ((obj3 != null) ? ((Component)obj3).GetComponent<CustomWeaponComponent>() : null);
							}
						}
					}
				}
			}
			CustomWeaponComponent customWeaponComponent = (CustomWeaponComponent)obj;
			if (!((Object)(object)customWeaponComponent == (Object)null))
			{
				PUI_InventoryItem val = __instance.m_inventorySlots[slot];
				WeaponPreAmmoUIContext weaponPreAmmoUIContext = new WeaponPreAmmoUIContext(customWeaponComponent.Weapon, clipAbs, inPackAbs, inPackRel, val.ShowAmmoClip, val.ShowAmmoPack, val.ShowAmmoTotalRel, val.ShowAmmoInfinite);
				customWeaponComponent.Invoke(weaponPreAmmoUIContext);
				clipAbs = weaponPreAmmoUIContext.Clip;
				inPackAbs = weaponPreAmmoUIContext.Reserve;
				inPackRel = weaponPreAmmoUIContext.TotalRel;
				val.ShowAmmoClip = weaponPreAmmoUIContext.ShowClip;
				val.ShowAmmoPack = weaponPreAmmoUIContext.ShowReserve;
				val.ShowAmmoTotalRel = weaponPreAmmoUIContext.ShowRel;
				val.ShowAmmoInfinite = weaponPreAmmoUIContext.ShowInfinite;
			}
		}

		[HarmonyPatch(typeof(PlayerBackpackManager), "ReceiveAmmoGive")]
		[HarmonyWrapSafe]
		[HarmonyPrefix]
		private static void AmmoPackCallback(ref pAmmoGive data)
		{
			SNet_Player val = default(SNet_Player);
			if (!((pPlayer)(ref data.targetPlayer)).TryGetPlayer(ref val))
			{
				return;
			}
			SNet_IPlayerAgent playerAgent = val.PlayerAgent;
			if ((Object)(object)((playerAgent != null) ? ((Il2CppObjectBase)playerAgent).TryCast<PlayerAgent>() : null) == (Object)null)
			{
				return;
			}
			BackpackItem val2 = default(BackpackItem);
			if (PlayerBackpackManager.TryGetItem(val, (InventorySlot)1, ref val2))
			{
				Item instance = val2.Instance;
				CustomWeaponComponent customWeaponComponent = ((instance != null) ? ((Component)instance).GetComponent<CustomWeaponComponent>() : null);
				if ((Object)(object)customWeaponComponent != (Object)null)
				{
					WeaponPreAmmoPackContext weaponPreAmmoPackContext = new WeaponPreAmmoPackContext(customWeaponComponent.Weapon, data.ammoStandardRel);
					customWeaponComponent.Invoke(weaponPreAmmoPackContext);
					data.ammoStandardRel = weaponPreAmmoPackContext.AmmoRel;
				}
			}
			BackpackItem val3 = default(BackpackItem);
			if (PlayerBackpackManager.TryGetItem(val, (InventorySlot)2, ref val3))
			{
				Item instance2 = val3.Instance;
				CustomWeaponComponent customWeaponComponent2 = ((instance2 != null) ? ((Component)instance2).GetComponent<CustomWeaponComponent>() : null);
				if ((Object)(object)customWeaponComponent2 != (Object)null)
				{
					WeaponPreAmmoPackContext weaponPreAmmoPackContext2 = new WeaponPreAmmoPackContext(customWeaponComponent2.Weapon, data.ammoSpecialRel);
					customWeaponComponent2.Invoke(weaponPreAmmoPackContext2);
					data.ammoSpecialRel = weaponPreAmmoPackContext2.AmmoRel;
				}
			}
		}

		[HarmonyPatch(typeof(PlayerBackpackManager), "ReceiveAmmoGive")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void PostAmmoPackCallback(ref pAmmoGive data)
		{
			SNet_Player val = default(SNet_Player);
			if (((pPlayer)(ref data.targetPlayer)).TryGetPlayer(ref val))
			{
				PlayerBackpack backpack = PlayerBackpackManager.GetBackpack(val);
				BackpackItem val2 = default(BackpackItem);
				if (backpack.TryGetBackpackItem((InventorySlot)1, ref val2))
				{
					Item instance = val2.Instance;
					CustomWeaponComponent customWeaponComponent = ((instance != null) ? ((Component)instance).GetComponent<CustomWeaponComponent>() : null);
					customWeaponComponent?.Invoke(new WeaponPostAmmoPackContext(backpack.AmmoStorage, customWeaponComponent.Weapon));
				}
				BackpackItem val3 = default(BackpackItem);
				if (backpack.TryGetBackpackItem((InventorySlot)2, ref val3))
				{
					Item instance2 = val3.Instance;
					CustomWeaponComponent customWeaponComponent2 = ((instance2 != null) ? ((Component)instance2).GetComponent<CustomWeaponComponent>() : null);
					customWeaponComponent2?.Invoke(new WeaponPostAmmoPackContext(backpack.AmmoStorage, customWeaponComponent2.Weapon));
				}
			}
		}

		[HarmonyPatch(typeof(PlayerInventoryLocal), "DoReload")]
		[HarmonyPatch(typeof(PlayerInventoryBase), "DoReload")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void ReloadCallback(PlayerInventoryBase __instance)
		{
			ItemEquippable wieldedItem = __instance.m_wieldedItem;
			object obj;
			if (wieldedItem == null)
			{
				obj = null;
			}
			else
			{
				BulletWeapon obj2 = ((Il2CppObjectBase)wieldedItem).TryCast<BulletWeapon>();
				obj = ((obj2 != null) ? ((Component)obj2).GetComponent<CustomWeaponComponent>() : null);
			}
			CustomWeaponComponent customWeaponComponent = (CustomWeaponComponent)obj;
			if (!((Object)(object)customWeaponComponent == (Object)null))
			{
				customWeaponComponent.Invoke(new WeaponPostReloadContext(customWeaponComponent.Weapon));
			}
		}

		[HarmonyPatch(typeof(PlayerAmmoStorage), "FillAllClips")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void PostFillAllClipsCallback(PlayerAmmoStorage __instance)
		{
			BackpackItem val = default(BackpackItem);
			if (__instance.m_playerBackpack.TryGetBackpackItem((InventorySlot)1, ref val))
			{
				Item instance = val.Instance;
				CustomWeaponComponent customWeaponComponent = ((instance != null) ? ((Component)instance).GetComponent<CustomWeaponComponent>() : null);
				customWeaponComponent?.Invoke(new WeaponPostAmmoInitContext(__instance, __instance.StandardAmmo, customWeaponComponent.Weapon));
			}
			BackpackItem val2 = default(BackpackItem);
			if (__instance.m_playerBackpack.TryGetBackpackItem((InventorySlot)2, ref val2))
			{
				Item instance2 = val2.Instance;
				CustomWeaponComponent customWeaponComponent2 = ((instance2 != null) ? ((Component)instance2).GetComponent<CustomWeaponComponent>() : null);
				customWeaponComponent2?.Invoke(new WeaponPostAmmoInitContext(__instance, __instance.SpecialAmmo, customWeaponComponent2.Weapon));
			}
		}
	}
	[HarmonyPatch]
	internal static class PlayerLocalPatches
	{
		[HarmonyPatch(typeof(PUI_LocalPlayerStatus), "UpdateHealth")]
		[HarmonyWrapSafe]
		[HarmonyPrefix]
		private static void UpdateHealth(PUI_LocalPlayerStatus __instance, float health, bool meleeBuffActive)
		{
			if (__instance.m_lastHealthVal <= 0.14f && health > 0.14f && __instance.m_warningRoutine != null)
			{
				__instance.m_healthWarningLooping = true;
			}
		}
	}
	[HarmonyPatch]
	internal static class ShotgunPatches
	{
		[HarmonyPatch(typeof(Shotgun), "Fire")]
		[HarmonyWrapSafe]
		[HarmonyPrefix]
		private static void Pre_Fire(Shotgun __instance)
		{
			WeaponRayPatches.CachedWeapon = (BulletWeapon?)(object)__instance;
		}

		[HarmonyPatch(typeof(Shotgun), "Fire")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void Post_Fire(Shotgun __instance)
		{
			WeaponRayPatches.CachedWeapon = null;
		}
	}
	[HarmonyPatch]
	internal static class WeaponArchetypePatches
	{
		[HarmonyPatch(typeof(BulletWeaponArchetype), "SetOwner")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void SetupCallback(BulletWeaponArchetype __instance, PlayerAgent owner)
		{
			if (!((Object)(object)owner == (Object)null))
			{
				CustomWeaponComponent component = ((Component)__instance.m_weapon).GetComponent<CustomWeaponComponent>();
				if (!((Object)(object)component == (Object)null))
				{
					component.OwnerInit();
				}
			}
		}

		[HarmonyPatch(typeof(BWA_Burst), "OnStartFiring")]
		[HarmonyPatch(typeof(BWA_Auto), "OnStartFiring")]
		[HarmonyPatch(typeof(BulletWeaponArchetype), "OnStartFiring")]
		[HarmonyWrapSafe]
		[HarmonyPrefix]
		private static bool StartFireCallback(BulletWeaponArchetype __instance)
		{
			BulletWeapon weapon = __instance.m_weapon;
			CustomWeaponComponent customWeaponComponent = ((weapon != null) ? ((Component)weapon).GetComponent<CustomWeaponComponent>() : null);
			if ((Object)(object)customWeaponComponent == (Object)null)
			{
				return true;
			}
			customWeaponComponent.CancelShot = false;
			WeaponPreStartFireContext weaponPreStartFireContext = new WeaponPreStartFireContext(__instance.m_weapon);
			customWeaponComponent.Invoke(weaponPreStartFireContext);
			customWeaponComponent.UpdateStoredFireRate(__instance);
			if (!weaponPreStartFireContext.Allow)
			{
				customWeaponComponent.StoreCancelShot();
			}
			return weaponPreStartFireContext.Allow;
		}

		[HarmonyPatch(typeof(BWA_Burst), "OnStartFiring")]
		[HarmonyPatch(typeof(BWA_Auto), "OnStartFiring")]
		[HarmonyPatch(typeof(BulletWeaponArchetype), "OnStartFiring")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void PostStartFireCallback(BulletWeaponArchetype __instance)
		{
			BulletWeapon weapon = __instance.m_weapon;
			CustomWeaponComponent customWeaponComponent = ((weapon != null) ? ((Component)weapon).GetComponent<CustomWeaponComponent>() : null);
			if (!((Object)(object)customWeaponComponent == (Object)null))
			{
				if (customWeaponComponent.ResetShotIfCancel(__instance))
				{
					customWeaponComponent.CancelShot = false;
					__instance.m_readyToFire = false;
				}
				else
				{
					customWeaponComponent.Invoke(new WeaponPostStartFireContext(__instance.m_weapon));
				}
			}
		}

		[HarmonyPatch(typeof(BWA_Auto), "OnFireShot")]
		[HarmonyPatch(typeof(BWA_Burst), "OnFireShot")]
		[HarmonyPatch(typeof(BWA_Semi), "OnFireShot")]
		[HarmonyWrapSafe]
		[HarmonyPrefix]
		private static bool PreFireCallback(BulletWeaponArchetype __instance)
		{
			BulletWeapon weapon = __instance.m_weapon;
			CustomWeaponComponent customWeaponComponent = ((weapon != null) ? ((Component)weapon).GetComponent<CustomWeaponComponent>() : null);
			if ((Object)(object)customWeaponComponent == (Object)null)
			{
				return true;
			}
			if (customWeaponComponent.CancelShot)
			{
				return false;
			}
			WeaponPreFireContext weaponPreFireContext = new WeaponPreFireContext(__instance.m_weapon);
			customWeaponComponent.Invoke(weaponPreFireContext);
			if (!weaponPreFireContext.Allow)
			{
				customWeaponComponent.StoreCancelShot();
			}
			return weaponPreFireContext.Allow;
		}

		[HarmonyPatch(typeof(BWA_Auto), "OnFireShot")]
		[HarmonyPatch(typeof(BWA_Burst), "OnFireShot")]
		[HarmonyPatch(typeof(BWA_Semi), "OnFireShot")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void PostFireCallback(BulletWeaponArchetype __instance)
		{
			BulletWeapon weapon = __instance.m_weapon;
			CustomWeaponComponent customWeaponComponent = ((weapon != null) ? ((Component)weapon).GetComponent<CustomWeaponComponent>() : null);
			if (!((Object)(object)customWeaponComponent == (Object)null) && !customWeaponComponent.CancelShot)
			{
				customWeaponComponent.Invoke(new WeaponPostFireContext(__instance.m_weapon));
			}
		}

		[HarmonyPatch(typeof(BulletWeaponArchetype), "PostFireCheck")]
		[HarmonyWrapSafe]
		[HarmonyPrefix]
		private static void PrePostFireCallback(BulletWeaponArchetype __instance)
		{
			BulletWeapon weapon = __instance.m_weapon;
			CustomWeaponComponent customWeaponComponent = ((weapon != null) ? ((Component)weapon).GetComponent<CustomWeaponComponent>() : null);
			if (!((Object)(object)customWeaponComponent == (Object)null))
			{
				customWeaponComponent.ResetShotIfCancel(__instance);
			}
		}

		[HarmonyPatch(typeof(BulletWeaponArchetype), "PostFireCheck")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void PostPostFireCallback(BulletWeaponArchetype __instance)
		{
			BulletWeapon weapon = __instance.m_weapon;
			CustomWeaponComponent customWeaponComponent = ((weapon != null) ? ((Component)weapon).GetComponent<CustomWeaponComponent>() : null);
			if (!((Object)(object)customWeaponComponent == (Object)null))
			{
				if (customWeaponComponent.CancelShot)
				{
					customWeaponComponent.CancelShot = false;
					return;
				}
				customWeaponComponent.UpdateStoredFireRate(__instance);
				customWeaponComponent.ModifyFireRate(__instance);
			}
		}

		[HarmonyPatch(typeof(BWA_Burst), "OnStopFiring")]
		[HarmonyPatch(typeof(BWA_Auto), "OnStopFiring")]
		[HarmonyPatch(typeof(BulletWeaponArchetype), "OnStopFiring")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void StopFiringCallback(BulletWeaponArchetype __instance)
		{
			BulletWeapon weapon = __instance.m_weapon;
			CustomWeaponComponent customWeaponComponent = ((weapon != null) ? ((Component)weapon).GetComponent<CustomWeaponComponent>() : null);
			if (!((Object)(object)customWeaponComponent == (Object)null))
			{
				customWeaponComponent.Invoke(new WeaponPostStopFiringContext(__instance.m_weapon));
				customWeaponComponent.CancelShot = true;
			}
		}
	}
	[HarmonyPatch]
	internal static class WeaponPatches
	{
		private static uint _lastSearchID;

		private static float _origHitDamage;

		private static float _origHitPrecision;

		public static CustomWeaponComponent? CachedHitCWC { get; private set; }

		[HarmonyPatch(typeof(BulletWeapon), "OnGearSpawnComplete")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void SetupCallback(BulletWeapon __instance)
		{
			CustomWeaponManager.Current.AddWeaponListener(__instance);
			CustomWeaponData customWeaponData = CustomWeaponManager.Current.GetCustomWeaponData(((GameDataBlockBase<ArchetypeDataBlock>)(object)((ItemEquippable)__instance).ArchetypeData).persistentID);
			if (customWeaponData != null && !((Object)(object)((Component)__instance).gameObject.GetComponent<CustomWeaponComponent>() != (Object)null))
			{
				((Component)__instance).gameObject.AddComponent<CustomWeaponComponent>().Register(customWeaponData);
			}
		}

		[HarmonyPatch(typeof(BulletWeapon), "OnWield")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void UpdateCurrentWeapon(BulletWeapon __instance)
		{
			CustomWeaponComponent component = ((Component)__instance).GetComponent<CustomWeaponComponent>();
			if (!((Object)(object)component == (Object)null))
			{
				component.Invoke(new WeaponWieldContext(__instance));
				component.RefreshSoundDelay();
				_lastSearchID = 0u;
			}
		}

		[HarmonyPatch(typeof(BulletWeapon), "BulletHit")]
		[HarmonyWrapSafe]
		[HarmonyPrefix]
		private static void HitCallback(ref WeaponHitData weaponRayData, bool doDamage, float additionalDis, uint damageSearchID, ref bool allowDirectionalBonus)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Invalid comparison between Unknown and I4
			CachedHitCWC = null;
			if (!allowDirectionalBonus || weaponRayData.vfxBulletHit != null || !doDamage || (!((Agent)weaponRayData.owner).IsLocallyOwned && (!SNet.IsMaster || !weaponRayData.owner.Owner.IsBot)))
			{
				return;
			}
			IDamageable damageableFromData = DamageableUtil.GetDamageableFromData(weaponRayData);
			IDamageable val = ((((damageableFromData != null) ? damageableFromData.GetBaseDamagable() : null) != null) ? damageableFromData.GetBaseDamagable() : damageableFromData);
			if (damageSearchID != 0 && val != null && val.TempSearchID == damageSearchID)
			{
				return;
			}
			ItemEquippable wieldedItem = weaponRayData.owner.Inventory.WieldedItem;
			CustomWeaponComponent customWeaponComponent = ((wieldedItem != null) ? ((Component)wieldedItem).GetComponent<CustomWeaponComponent>() : null);
			if ((Object)(object)customWeaponComponent == (Object)null)
			{
				Agent val2 = ((damageableFromData != null) ? damageableFromData.GetBaseAgent() : null);
				if ((Object)(object)val2 != (Object)null && (int)val2.Type == 1 && val2.Alive)
				{
					KillTrackerManager.ClearHit(((Il2CppObjectBase)val2).TryCast<EnemyAgent>());
				}
				return;
			}
			if (damageableFromData != null && damageSearchID != 0)
			{
				if (_lastSearchID != damageSearchID)
				{
					_lastSearchID = damageSearchID;
					_origHitDamage = weaponRayData.damage;
					_origHitPrecision = weaponRayData.precisionMulti;
				}
				weaponRayData.damage = _origHitDamage;
				weaponRayData.precisionMulti = _origHitPrecision;
			}
			ApplyEWCBulletHit(customWeaponComponent, damageableFromData, ref weaponRayData, additionalDis, damageSearchID != 0, ref _origHitDamage, ref allowDirectionalBonus);
		}

		public static void ApplyEWCBulletHit(CustomWeaponComponent cwc, IDamageable? damageable, ref WeaponHitData weaponRayData, float additionalDis, bool pierce, ref float pierceDamage, ref bool doBackstab)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Invalid comparison between Unknown and I4
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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)
			CachedHitCWC = cwc;
			if (damageable != null)
			{
				WeaponDamageContext weaponDamageContext = new WeaponDamageContext(weaponRayData.damage, weaponRayData.precisionMulti, damageable, cwc.Weapon);
				cwc.Invoke(weaponDamageContext);
				weaponRayData.damage = weaponDamageContext.Damage.Value;
				weaponRayData.precisionMulti = weaponDamageContext.Precision.Value;
				if (pierce)
				{
					WeaponPierceContext weaponPierceContext = new WeaponPierceContext(pierceDamage, damageable, cwc.Weapon);
					cwc.Invoke(weaponPierceContext);
					pierceDamage = weaponPierceContext.Value;
				}
			}
			Agent val = ((damageable != null) ? damageable.GetBaseAgent() : null);
			if ((Object)(object)val != (Object)null && (int)val.Type == 1 && val.Alive)
			{
				Dam_EnemyDamageLimb val2 = ((Il2CppObjectBase)damageable).TryCast<Dam_EnemyDamageLimb>();
				RaycastHit rayHit = weaponRayData.rayHit;
				Vector3 point = ((RaycastHit)(ref rayHit)).point;
				Vector3 fireDir = weaponRayData.fireDir;
				float num = val2.ApplyDamageFromBehindBonus(1f, point, ((Vector3)(ref fireDir)).normalized, 1f);
				WeaponBackstabContext weaponBackstabContext = new WeaponBackstabContext(cwc.Weapon);
				cwc.Invoke(weaponBackstabContext);
				WeaponPreHitEnemyContext weaponPreHitEnemyContext = new WeaponPreHitEnemyContext(weaponRayData, additionalDis, num.Map(1f, 2f, 1f, weaponBackstabContext.Value), val2, cwc.Weapon, DamageType.Bullet);
				cwc.Invoke(weaponPreHitEnemyContext);
				KillTrackerManager.RegisterHit(weaponPreHitEnemyContext);
				if (weaponBackstabContext.Value > 1f)
				{
					WeaponHitData obj = weaponRayData;
					obj.damage *= weaponPreHitEnemyContext.Backstab / num;
				}
				else
				{
					doBackstab = false;
				}
			}
			else
			{
				cwc.Invoke(new WeaponPreHitContext(weaponRayData, additionalDis, cwc.Weapon));
			}
		}
	}
	[HarmonyPatch]
	internal static class WeaponRayPatches
	{
		public static BulletWeapon? CachedWeapon;

		private static CustomWeaponComponent? _cachedCWC;

		[HarmonyTargetMethod]
		private static MethodBase FindWeaponRayFunc(Harmony harmony)
		{
			return AccessTools.Method(typeof(Weapon), "CastWeaponRay", new Type[4]
			{
				typeof(Transform),
				typeof(WeaponHitData).MakeByRefType(),
				typeof(Vector3),
				typeof(int)
			}, (Type[])null);
		}

		[HarmonyWrapSafe]
		[HarmonyPrefix]
		private static void PreRayCallback(ref WeaponHitData weaponRayData, Vector3 originPos, int altRayCastMask)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (altRayCastMask != -1)
			{
				return;
			}
			if ((Object)(object)CachedWeapon != (Object)null)
			{
				_cachedCWC = ((Component)CachedWeapon).GetComponent<CustomWeaponComponent>();
			}
			else
			{
				PlayerAgent owner = weaponRayData.owner;
				object cachedCWC;
				if (owner == null)
				{
					cachedCWC = null;
				}
				else
				{
					ItemEquippable wieldedItem = owner.Inventory.WieldedItem;
					cachedCWC = ((wieldedItem != null) ? ((Component)wieldedItem).GetComponent<CustomWeaponComponent>() : null);
				}
				_cachedCWC = (CustomWeaponComponent?)cachedCWC;
			}
			if (!((Object)(object)_cachedCWC == (Object)null))
			{
				_cachedCWC.Invoke(new WeaponPreRayContext(weaponRayData, originPos, _cachedCWC.Weapon));
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void PostRayCallback(ref WeaponHitData weaponRayData, Vector3 originPos, int altRayCastMask, ref bool __result)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (altRayCastMask == -1 && !((Object)(object)_cachedCWC == (Object)null))
			{
				WeaponPostRayContext weaponPostRayContext = new WeaponPostRayContext(weaponRayData, originPos, _cachedCWC.Weapon, __result);
				_cachedCWC.Invoke(weaponPostRayContext);
				__result = weaponPostRayContext.Result;
			}
		}
	}
	[HarmonyPatch]
	internal static class WeaponRecoilPatches
	{
		private static BulletWeapon? _cachedWeapon;

		private static CustomWeaponComponent? _cachedComponent;

		[HarmonyPatch(typeof(BulletWeapon), "OnWield")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void UpdateCurrentWeapon(BulletWeapon __instance)
		{
			PlayerAgent owner = ((Item)__instance).Owner;
			if (owner != null && ((Agent)owner).IsLocallyOwned)
			{
				_cachedWeapon = __instance;
				_cachedComponent = ((Component)__instance).GetComponent<CustomWeaponComponent>();
			}
		}

		[HarmonyAfter(new string[] { "Dinorush.ExtraRecoilData" })]
		[HarmonyPatch(typeof(FPS_RecoilSystem), "ApplyRecoil")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void PostApplyRecoilCallback(FPS_RecoilSystem __instance, bool resetSimilarity, RecoilDataBlock recoilData)
		{
			//IL_0035: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_cachedComponent == (Object)null))
			{
				WeaponRecoilContext weaponRecoilContext = new WeaponRecoilContext(_cachedWeapon);
				_cachedComponent.Invoke(weaponRecoilContext);
				if (weaponRecoilContext.Value != 1f)
				{
					Vector2 val = default(Vector2);
					((Vector2)(ref val))..ctor(__instance.recoilDir.x * (weaponRecoilContext.Value - 1f), __instance.recoilDir.y * (weaponRecoilContext.Value - 1f));
					Vector2 currentRecoilForce = __instance.currentRecoilForce;
					currentRecoilForce.x -= val.x * (1f - recoilData.worldToViewSpaceBlendVertical);
					currentRecoilForce.y -= val.y * (1f - recoilData.worldToViewSpaceBlendHorizontal);
					Vector2 currentRecoilForceVP = __instance.currentRecoilForceVP;
					currentRecoilForceVP.x -= val.x * recoilData.worldToViewSpaceBlendVertical;
					currentRecoilForceVP.y -= val.y * recoilData.worldToViewSpaceBlendHorizontal;
					Vector2 recoilDir = __instance.recoilDir;
					((Vector2)(ref recoilDir)).Set(__instance.recoilDir.x * weaponRecoilContext.Value, __instance.recoilDir.y * weaponRecoilContext.Value);
					__instance.currentRecoilForce = currentRecoilForce;
					__instance.currentRecoilForceVP = currentRecoilForceVP;
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class WeaponSyncPatches
	{
		[HarmonyPatch(typeof(BulletWeaponSynced), "OnGearSpawnComplete")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void Post_SetupSynced(BulletWeaponSynced __instance)
		{
			CustomWeaponComponent component = ((Component)__instance).GetComponent<CustomWeaponComponent>();
			if (!((Object)(object)component == (Object)null))
			{
				component.SetToSync();
			}
		}

		[HarmonyPatch(typeof(ShotgunSynced), "Fire")]
		[HarmonyPatch(typeof(BulletWeaponSynced), "Fire")]
		[HarmonyWrapSafe]
		[HarmonyPostfix]
		private static void Post_FireSynced(BulletWeaponSynced __instance)
		{
			CustomWeaponComponent component = ((Component)__instance).GetComponent<CustomWeaponComponent>();
			if (!((Object)(object)component == (Object)null))
			{
				component.Invoke(new WeaponPreFireContextSync((BulletWeapon)(object)__instance));
				component.UpdateStoredFireRate(((BulletWeapon)__instance).m_archeType);
				component.ModifyFireRate(__instance);
				component.Invoke(new WeaponPostFireContextSync((BulletWeapon)(object)__instance));
			}
		}
	}
}
namespace ExtraWeaponCustomization.Networking
{
	public abstract class SyncedEvent<T> where T : struct
	{
		public delegate void ReceiveHandler(T packet);

		private bool _isSetup;

		public abstract string GUID { get; }

		public bool IsSetup => _isSetup;

		public string EventName { get; private set; } = string.Empty;


		public event ReceiveHandler? OnReceive;

		public event ReceiveHandler? OnReceiveLocal;

		public void Setup()
		{
			if (!_isSetup)
			{
				EventName = "EWC" + GUID;
				NetworkAPI.RegisterEvent<T>(EventName, (Action<ulong, T>)ReceiveClient_Callback);
				_isSetup = true;
			}
		}

		public void Send(T packetData, SNet_Player? target = null, SNet_ChannelType priority = 4)
		{
			//IL_0020: 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)
			if ((Object)(object)target != (Object)null)
			{
				NetworkAPI.InvokeEvent<T>(EventName, packetData, target, priority);
			}
			else
			{
				NetworkAPI.InvokeEvent<T>(EventName, packetData, priority);
			}
			ReceiveLocal_Callback(packetData);
		}

		private void ReceiveLocal_Callback(T packet)
		{
			ReceiveLocal(packet);
			this.OnReceiveLocal?.Invoke(packet);
		}

		private void ReceiveClient_Callback(ulong sender, T packet)
		{
			Receive(packet);
			this.OnReceive?.Invoke(packet);
		}

		protected virtual void ReceiveLocal(T packet)
		{
		}

		protected virtual void Receive(T packet)
		{
		}
	}
	public abstract class SyncedEventMasterOnly<T> : SyncedEvent<T> where T : struct
	{
		public void Send(T packet, SNet_ChannelType priority = 4)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!SNet.IsMaster)
			{
				Send(packet, SNet.Master, priority);
			}
			else
			{
				Receive(packet);
			}
		}
	}
}
namespace ExtraWeaponCustomization.Networking.Structs
{
	public struct LowResColor
	{
		public byte r;

		public byte g;

		public byte b;

		public byte a;

		private static Color s_color = Color.black;

		public static implicit operator Color(LowResColor lowResColor)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			s_color.r = (float)(int)lowResColor.r / 255f;
			s_color.g = (float)(int)lowResColor.g / 255f;
			s_color.b = (float)(int)lowResColor.b / 255f;
			s_color.a = (float)(int)lowResColor.a / 255f;
			return s_color;
		}

		public static implicit operator LowResColor(Color color)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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)
			LowResColor result = default(LowResColor);
			result.r = (byte)(color.r * 255f);
			result.g = (byte)(color.g * 255f);
			result.b = (byte)(color.b * 255f);
			result.a = (byte)(color.a * 255f);
			return result;
		}
	}
}
namespace ExtraWeaponCustomization.JSON
{
	internal static class CustomWeaponTemplate
	{
		internal static CustomWeaponData CreateTemplate()
		{
			return new CustomWeaponData
			{
				ArchetypeID = 0u,
				Name = "Example",
				Properties = new List<IWeaponProperty>
				{
					new AmmoMod(),
					new DamageMod(),
					new DamageModPerTarget(),
					new DamageOverTime(),
					new Explosive(),
					new FireRateMod(),
					new HealthMod(),
					new RecoilMod(),
					new Accelerate(),
					new AmmoCap(),
					new ArmorPierce(),
					new AutoAim(),
					new AutoTrigger(),
					new BackstabMulti(),
					new EnforceFireRate(),
					new HoldBurst(),
					new PierceMulti(),
					new Projectile(),
					new ReserveClip(),
					new ThickBullet(),
					new TumorMulti()
				}
			};
		}
	}
	public static class EWCJson
	{
		private static readonly JsonSerializerOptions _setting;

		static EWCJson()
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			_setting = new JsonSerializerOptions
			{
				ReadCommentHandling = JsonCommentHandling.Skip,
				IncludeFields = true,
				PropertyNameCaseInsensitive = true,
				WriteIndented = true,
				IgnoreReadOnlyProperties = true
			};
			_setting.Converters.Add(new JsonStringEnumConverter());
			_setting.Converters.Add(new WeaponPropertyConverter());
			_setting.Converters.Add(new TriggerConverter());
			_setting.Converters.Add(new TriggerCoordinatorConverter());
			_setting.Converters.Add((JsonConverter)new ColorConverter());
			if (MTFOPartialDataUtil.IsLoaded)
			{
				_setting.Converters.Add(MTFOPartialDataUtil.PersistentIDConverter);
				_setting.Converters.Add(MTFOPartialDataUtil.LocalizedTextConverter);
				EWCLogger.Log("PartialData support found!");
			}
			else
			{
				_setting.Converters.Add((JsonConverter)new LocalizedTextConverter());
			}
		}

		public static T? Deserialize<T>(string json)
		{
			return JsonSerializer.Deserialize<T>(json, _setting);
		}

		public static object? Deserialize(Type type, string json)
		{
			return JsonSerializer.Deserialize(json, type, _setting);
		}

		public static string Serialize<T>(T value)
		{
			return JsonSerializer.Serialize(value, _setting);
		}
	}
}
namespace ExtraWeaponCustomization.JSON.Converters
{
	public sealed class TriggerConverter : JsonConverter<ITrigger>
	{
		public override ITrigger? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
		{
			if (reader.TokenType == JsonTokenType.String)
			{
				return ITrigger.GetTrigger(reader.GetString());
			}
			if (reader.TokenType != JsonTokenType.StartObject)
			{
				throw new JsonException("Expected Trigger to be either a string or object");
			}
			ITrigger trigger = CreateTriggerInstance(reader);
			if (trigger == null)
			{
				return null;
			}
			while (reader.Read())
			{
				if (reader.TokenType == JsonTokenType.EndObject)
				{
					return trigger;
				}
				if (reader.TokenType != JsonTokenType.PropertyName)
				{
					throw new JsonException("Expected PropertyName token");
				}
				string @string = reader.GetString();
				reader.Read();
				trigger.DeserializeProperty(@string.ToLowerInvariant().Replace(" ", ""), ref reader, options);
			}
			throw new JsonException("Expected EndObject token");
		}

		public override void Write(Utf8JsonWriter writer, ITrigger? value, JsonSerializerOptions options)
		{
			writer.WriteStringValue(value?.Name ?? "Invalid");
		}

		private static ITrigger? CreateTriggerInstance(Utf8JsonReader reader)
		{
			if (reader.TokenType != JsonTokenType.StartObject)
			{
				return null;
			}
			while (reader.Read())
			{
				if (reader.TokenType == JsonTokenType.EndObject || reader.TokenType == JsonTokenType.StartObject)
				{
					throw new JsonException("Trigger object does not contain Name field.");
				}
				if (reader.TokenType == JsonTokenType.PropertyName && !(reader.GetString().ToLowerInvariant() != "name"))
				{
					reader.Read();
					return ITrigger.GetTrigger(reader.GetString() ?? throw new JsonException("Name field cannot be empty in trigger object."));
				}
			}
			return null;
		}
	}
	public sealed class TriggerCoordinatorConverter : JsonConverter<TriggerCoordinator>
	{
		public override TriggerCoordinator? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
		{
			TriggerCoordinator triggerCoordinator = new TriggerCoordinator();
			if (reader.TokenType == JsonTokenType.String)
			{
				ITrigger trigger = JsonSerializer.Deserialize<ITrigger>(ref reader, options);
				if (trigger != null)
				{
					triggerCoordinator.Activate.Add(trigger);
					return triggerCoordinator;
				}
				return null;
			}
			if (reader.TokenType != JsonTokenType.StartObject)
			{
				throw new JsonException("Expected Trigger Coordinator to be either a string or object");
			}
			ITrigger trigger2 = null;
			try
			{
				trigger2 = JsonSerializer.Deserialize<ITrigger>(ref reader, options);
			}
			catch (JsonException)
			{
			}
			if (trigger2 != null)
			{
				triggerCoordinator.Activate.Add(trigger2);
				return triggerCoordinator;
			}
			while (reader.Read())
			{
				if (reader.TokenType == JsonTokenType.EndObject)
				{
					if (triggerCoordinator.Activate.Count <= 0)
					{
						return null;
					}
					return triggerCoordinator;
				}
				if (reader.TokenType != JsonTokenType.PropertyName)
				{
					throw new JsonException("Expected PropertyName token");
				}
				string? @string = reader.GetString();
				reader.Read();
				switch (@string.ToLowerInvariant().Replace(" ", ""))
				{
				case "cap":
					triggerCoordinator.Cap = reader.GetUInt32();
					break;
				case "cooldown":
					triggerCoordinator.Cooldown = reader.GetSingle();
					break;
				case "chance":
					triggerCoordinator.Chance = reader.GetSingle();
					break;
				case "cooldownonapply":
					triggerCoordinator.CooldownOnApply = reader.GetSingle();
					break;
				case "activate":
				case "triggers":
				case "trigger":
				{
					triggerCoordinator.Activate = DeserializeTriggers(ref reader, options);
					List<ITrigger> activate = triggerCoordinator.Activate;
					if (activate == null || !activate.Any())
					{
						return null;
					}
					break;
				}
				case "apply":
					triggerCoordinator.Apply = DeserializeTriggers(ref reader, options);
					break;
				case "reset":
					triggerCoordinator.Reset = DeserializeTriggers(ref reader, options);
					break;
				}
			}
			throw new JsonException("Expected EndObject token");
		}

		private static List<ITrigger>? DeserializeTriggers(ref Utf8JsonReader reader, JsonSerializerOptions options)
		{
			if (reader.TokenType == JsonTokenType.String || reader.TokenType == JsonTokenType.StartObject)
			{
				ITrigger trigger = JsonSerializer.Deserialize<ITrigger>(ref reader, options);
				if (trigger == null)
				{
					return null;
				}
				return new List<ITrigger> { trigger };
			}
			if (reader.TokenType == JsonTokenType.StartArray)
			{
				List<ITrigger> list = new List<ITrigger>();
				reader.Read();
				while (reader.TokenType != JsonTokenType.EndArray)
				{
					ITrigger trigger2 = JsonSerializer.Deserialize<ITrigger>(ref reader, options);
					reader.Read();
					if (trigger2 == null)
					{
						return null;
					}
					list.Add(trigger2);
				}
				if (!list.Any())
				{
					return null;
				}
				return list;
			}
			throw new JsonException("Expected trigger or list of triggers when deserializing triggers for Coordinator");
		}

		public override void Write(Utf8JsonWriter writer, TriggerCoordinator? value, JsonSerializerOptions options)
		{
			writer.WriteStringValue(value?.Activate[0].Name ?? "Invalid");
		}
	}
	public sealed class WeaponPropertyConverter : JsonConverter<IWeaponProperty>
	{
		private static readonly string PropertyNamespace = typeof(IWeaponProperty).Namespace;

		public override IWeaponProperty? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
		{
			IWeaponProperty weaponProperty = CreatePropertyInstance(reader);
			if (weaponProperty == null)
			{
				return null;
			}
			while (reader.Read())
			{
				if (reader.TokenType == JsonTokenType.EndObject)
				{
					return weaponProperty;
				}
				if (reader.TokenType != JsonTokenType.PropertyName)
				{
					throw new JsonException("Expected PropertyName token");
				}
				string @string = reader.GetString();
				reader.Read();
				weaponProperty.DeserializeProperty(@string.ToLowerInvariant().Replace(" ", ""), ref reader, options);
			}
			throw new JsonException("Expected EndObject token");
		}

		public override void Write(Utf8JsonWriter writer, IWeaponProperty value, JsonSerializerOptions options)
		{
			value.Serialize(writer, options);
		}

		private static IWeaponProperty? CreatePropertyInstance(Utf8JsonReader reader)
		{
			if (reader.TokenType != JsonTokenType.StartObject)
			{
				return null;
			}
			while (reader.Read())
			{
				if (reader.TokenType == JsonTokenType.EndObject || reader.TokenType == JsonTokenType.StartObject)
				{
					throw new JsonException("Weapon property does not contain Name field.");
				}
				if (reader.TokenType == JsonTokenType.PropertyName && !(reader.GetString().ToLowerInvariant() != "name"))
				{
					reader.Read();
					string @string = reader.GetString();
					if (@string == null)
					{
						throw new JsonException("Name field cannot be empty in weapon property.");
					}
					@string = @string.Replace(" ", "");
					Type? obj = Type.GetType(PropertyNamespace + ".Effects." + @string, throwOnError: false, ignoreCase: true) ?? Type.GetType(PropertyNamespace + ".Traits." + @string, throwOnError: false, ignoreCase: true);
					if (obj == null)
					{
						throw new JsonException("Unable to find corresponding weapon property for \"" + @string + "\"");
					}
					return (IWeaponProperty)Activator.CreateInstance(obj);
				}
			}
			return null;
		}
	}
}
namespace ExtraWeaponCustomization.Dependencies
{
	internal static class EXPAPIWrapper
	{
		public const string PLUGIN_GUID = "Endskill.GTFuckingXP";

		private const string CacheKey = "EndskApi";

		private const string EnemyKillKey = "EnemyKillCallbacks";

		public static bool HasEXP => ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey("Endskill.GTFuckingXP");

		public static void ApplyMod(ref float damage)
		{
			if (HasEXP)
			{
				EXPDamageMod(ref damage);
			}
		}

		public static void RegisterDamage(EnemyAgent enemy, PlayerAgent? source, float damage, bool willKill)
		{
			if (HasEXP)
			{
				EXPDidDamage(enemy, source, damage, willKill);
			}
		}

		private static void EXPDamageMod(ref float damage)
		{
			damage *= CacheApiWrapper.GetActiveLevel().WeaponDamageMultiplier;
		}

		private static void EXPDidDamage(EnemyAgent enemy, PlayerAgent? source, float damage, bool willKill)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if ((Object)(object)source == (Object)null)
			{
				return;
			}
			Dictionary<IntPtr, EnemyKillDistribution> instance = CacheApi.GetInstance<Dictionary<IntPtr, EnemyKillDistribution>>("EndskApi");
			if (!instance.TryGetValue(((Il2CppObjectBase)enemy).Pointer, out var value))
			{
				value = new EnemyKillDistribution(enemy);
				instance[((Il2CppObjectBase)enemy).Pointer] = value;
			}
			value.AddDamageDealtByPlayerAgent(source, damage);
			if (!willKill)
			{
				return;
			}
			value.LastHitDealtBy = source;
			value.lastHitType = (LastHitType)1;
			List<Action<EnemyKillDistribution>> list = default(List<Action<EnemyKillDistribution>>);
			if (!CacheApi.TryGetInformation<List<Action<EnemyKillDistribution>>>((object)"EnemyKillCallbacks", ref list, "EndskApi", false))
			{
				return;
			}
			foreach (Action<EnemyKillDistribution> item in list)
			{
				item(value);
			}
		}
	}
	public static class KillAPIWrapper
	{
		public const string PLUGIN_GUID = "randomuserhi.KillIndicatorFix";

		private const long MAX_DELAY = 500L;

		public static void Init()
		{
			Kill.OnKillIndicator = (Action<EnemyAgent, ItemEquippable, long>)Delegate.Combine(Kill.OnKillIndicator, new Action<EnemyAgent, ItemEquippable, long>(RunKillCallbacks));
		}

		public static void TagEnemy(EnemyAgent enemy, ItemEquippable? item = null, Vector3? localHitPosition = null)
		{
			Kill.TagEnemy(enemy, item, localHitPosition);
		}

		public static void RunKillCallbacks(EnemyAgent enemy, ItemEquippable? item, long delay)
		{
			if (delay > 500)
			{
				return;
			}
			WeaponPreHitEnemyContext killHitContext = KillTrackerManager.GetKillHitContext((Agent?)(object)enemy);
			if (killHitContext != null)
			{
				CustomWeaponComponent component = ((Component)killHitContext.Weapon).GetComponent<CustomWeaponComponent>();
				if (!((Object)(object)component == (Object)null))
				{
					component.Invoke(new WeaponPostKillContext(killHitContext));
				}
			}
		}
	}
}
namespace ExtraWeaponCustomization.CustomWeapon
{
	public sealed class CustomWeaponComponent : MonoBehaviour
	{
		private readonly ContextController _contextController;

		private AutoAim? _autoAim;

		private bool _ownerSet;

		private readonly HashSet<Type> _propertyTypes;

		private float _lastShotTimer;

		private float _lastBurstTimer;

		private float _lastFireRate;

		private readonly float _fireRate;

		private readonly float _burstDelay;

		public BulletWeapon Weapon { get; private set; }

		public bool CancelShot { get; set; }

		public float CurrentFireRate { get; private set; }

		public float CurrentBurstDelay { get; private set; }

		public CustomWeaponComponent(IntPtr value)
			: base(value)
		{
			_contextController = new ContextController();
			_propertyTypes = new HashSet<Type>();
			BulletWeapon component = ((Component)this).GetComponent<BulletWeapon>();
			if ((Object)(object)component == (Object)null)
			{
				throw new ArgumentException("Parent Object", "Custom Weapon Component was added to an object without a BulletWeapon component.");
			}
			Weapon = component;
			_fireRate = 1f / Math.Max(Weapon.m_archeType.ShotDelay(), 0.001953125f);
			_lastFireRate = _fireRate;
			CurrentFireRate = _fireRate;
			_burstDelay = Weapon.m_archeType.BurstDelay();
			CurrentBurstDelay = _burstDelay;
			_ownerSet = false;
		}

		public void OwnerInit()
		{
			if (!_ownerSet)
			{
				_autoAim?.OnEnable();
				_ownerSet = true;
			}
		}

		public void SetToSync()
		{
			Clear();
			_contextController.ChangeToSyncContexts();
			Register(CustomWeaponManager.Current.GetCustomWeaponData(((ItemEquippable)Weapon).ArchetypeID));
			_autoAim = null;
		}

		public void Update()
		{
			if (_ownerSet)
			{
				_autoAim?.Update();
			}
		}

		public void OnEnable()
		{
			if (_ownerSet)
			{
				_autoAim?.OnEnable();
			}
		}

		public void OnDisable()
		{
			if (_ownerSet)
			{
				_autoAim?.OnDisable();
			}
		}

		[HideFromIl2Cpp]
		public void Invoke<TContext>(TContext context) where TContext : IWeaponContext
		{
			_contextController.Invoke(context);
		}

		[HideFromIl2Cpp]
		public void Register(IWeaponProperty property)
		{
			if (property is AutoAim autoAim && _autoAim == null)
			{
				_autoAim = autoAim;
			}
			_contextController.Register(property);
			_propertyTypes.Add(property.GetType());
		}

		[HideFromIl2Cpp]
		public void Register(CustomWeaponData? data)
		{
			if (data == null)
			{
				return;
			}
			foreach (IWeaponProperty item in data.Properties.ConvertAll((IWeaponProperty property) => property.Clone()))
			{
				Register(item);
			}
			Invoke(new WeaponPostSetupContext(Weapon));
		}

		public void Clear()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			Invoke(new WeaponClearContext(Weapon));
			_propertyTypes.Clear();
			_contextController.Clear();
			_autoAim = null;
			_ownerSet = false;
			CurrentFireRate = _fireRate;
			CurrentBurstDelay = _burstDelay;
			((ItemEquippable)Weapon).Sound.SetRTPCValue(GAME_PARAMETERS.FIREDELAY, 1f / CurrentFireRate);
		}

		[HideFromIl2Cpp]
		public bool HasProperty(Type type)
		{
			return _propertyTypes.Contains(type);
		}

		public void StoreCancelShot()
		{
			if (!CancelShot)
			{
				Invoke(new WeaponCancelFireContext(Weapon));
				CancelShot = true;
			}
		}

		public bool ResetShotIfCancel(BulletWeaponArchetype archetype)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Invalid comparison between Unknown and I4
			if (CancelShot)
			{
				archetype.m_fireHeld = false;
				archetype.m_nextShotTimer = _lastShotTimer;
				archetype.m_nextBurstTimer = _lastBurstTimer;
				CurrentFireRate = _lastFireRate;
				((ItemEquippable)Weapon).Sound.SetRTPCValue(GAME_PARAMETERS.FIREDELAY, 1f / CurrentFireRate);
				if ((int)archetype.m_archetypeData.FireMode == 1)
				{
					((Il2CppObjectBase)archetype).TryCast<BWA_Burst>().m_burstCurrentCount = 0;
				}
				return true;
			}
			return false;
		}

		public void UpdateStoredFireRate(BulletWeaponArchetype archetype)
		{
			_lastFireRate = CurrentFireRate;
			_lastShotTimer = archetype.m_nextShotTimer;
			_lastBurstTimer = archetype.m_nextBurstTimer;
			WeaponFireRateSetContext weaponFireRateSetContext = new WeaponFireRateSetContext(Weapon, _fireRate);
			Invoke(weaponFireRateSetContext);
			WeaponFireRateContext weaponFireRateContext = new WeaponFireRateContext(weaponFireRateSetContext.FireRate, Weapon);
			Invoke(weaponFireRateContext);
			if (CurrentFireRate != weaponFireRateContext.Value)
			{
				CurrentFireRate = Math.Clamp(weaponFireRateContext.Value, 0.001f, 512f);
				CurrentBurstDelay = _burstDelay * _fireRate / CurrentFireRate;
				RefreshSoundDelay();
			}
		}

		public void RefreshSoundDelay()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			((ItemEquippable)Weapon).Sound.SetRTPCValue(GAME_PARAMETERS.FIREDELAY, 1f / CurrentFireRate);
		}

		public void ModifyFireRate(BulletWeaponArchetype archetype)
		{
			archetype.m_nextShotTimer = Clock.Time + 1f / CurrentFireRate;
			if (archetype.BurstIsDone())
			{
				archetype.m_nextBurstTimer = Math.Max(Clock.Time + CurrentBurstDelay, archetype.m_nextShotTimer);
			}
		}

		public void ModifyFireRate(BulletWeaponSynced synced)
		{
			((BulletWeapon)synced).m_lastFireTime = Clock.Time + 1f / CurrentFireRate - ((ItemEquippable)Weapon).ArchetypeData.ShotDelay;
		}
	}
	public class CustomWeaponData
	{
		public const float MaxFireRate = 512f;

		public const float MinShotDelay = 0.001953125f;

		public uint ArchetypeID { get; set; }

		public string Name { get; set; } = string.Empty;


		public List<IWeaponProperty> Properties { get; set; } = new List<IWeaponProperty>();

	}
	public sealed class CustomWeaponManager
	{
		public static readonly CustomWeaponManager Current = new CustomWeaponManager();

		private readonly Dictionary<string, HashSet<uint>> _fileToIDs = new Dictionary<string, HashSet<uint>>();

		private readonly Dictionary<uint, CustomWeaponData> _customData = new Dictionary<uint, CustomWeaponData>();

		private readonly List<BulletWeapon> _listenCWs = new List<BulletWeapon>();

		private readonly LiveEditListener _liveEditListener;

		public string DEFINITION_PATH { get; private set; }

		public override string ToString()
		{
			return "Printing manager: " + _customData.ToString();
		}

		public void AddCustomWeaponData(CustomWeaponData? data, string file)
		{
			if (data != null)
			{
				_fileToIDs[file].Add(data.ArchetypeID);
				_customData[data.ArchetypeID] = data;
			}
		}

		private void FileChanged(LiveEditEventArgs e)
		{
			LiveEditEventArgs e2 = e;
			EWCLogger.Warning("LiveEdit File Changed: " + e2.FullPath);
			LiveEdit.TryReadFileContent(e2.FullPath, (Action<string>)delegate(string content)
			{
				ReadFileContent(e2.FullPath, content);
				PrintCustomIDs();
			});
		}

		private void FileDeleted(LiveEditEventArgs e)
		{
			EWCLogger.Warning("LiveEdit File Removed: " + e.FullPath);
			foreach (uint item in _fileToIDs[e.FullPath])
			{
				_customData.Remove(item);
			}
			for (int num = _listenCWs.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)_listenCWs[num] != (Object)null)
				{
					((Component)_listenCWs[num]).GetComponent<CustomWeaponComponent>()?.Clear();
				}
				else
				{
					_listenCWs.RemoveAt(num);
				}
			}
			_fileToIDs.Remove(e.FullPath);
			PrintCustomIDs();
		}

		private void FileCreated(LiveEditEventArgs e)
		{
			LiveEditEventArgs e2 = e;
			EWCLogger.Warning("LiveEdit File Created: " + e2.FullPath);
			LiveEdit.TryReadFileContent(e2.FullPath, (Action<string>)delegate(string content)
			{
				ReadFileContent(e2.FullPath, content);
				PrintCustomIDs();
			});
		}

		private void ReadFileContent(string file, string content)
		{
			if (!_fileToIDs.ContainsKey(file))
			{
				_fileToIDs[file] = new HashSet<uint>();
			}
			HashSet<uint> hashSet = _fileToIDs[file];
			foreach (uint item in hashSet)
			{
				_customData.Remove(item);
			}
			hashSet.Clear();
			List<CustomWeaponData> list = null;
			try
			{
				list = EWCJson.Deserialize<List<CustomWeaponData>>(content);
			}
			catch (JsonException ex)
			{
				EWCLogger.Error("Error parsing custom weapon json " + file);
				EWCLogger.Error(ex.Message);
			}
			if (list == null)
			{
				return;
			}
			foreach (CustomWeaponData item2 in list)
			{
				if (item2 != null && _customData.ContainsKey(item2.ArchetypeID))
				{
					EWCLogger.Warning("Duplicate archetype ID " + item2.ArchetypeID + " found. Previous name: " + _customData[item2.ArchetypeID].Name + ", new name: " + item2.Name);
				}
				AddCustomWeaponData(item2, file);
			}
			ResetCWCs();
		}

		public CustomWeaponData? GetCustomWeaponData(uint ArchetypeID)
		{
			if (!_customData.ContainsKey(ArchetypeID))
			{
				return null;
			}
			return _customData[ArchetypeID];
		}

		public void AddWeaponListener(BulletWeapon weapon)
		{
			BulletWeapon weapon2 = weapon;
			if (!_listenCWs.Any((BulletWeapon listener) => ((Object)listener).GetInstanceID() == ((Object)weapon2).GetInstanceID()))
			{
				_listenCWs.Add(weapon2);
			}
		}

		internal void ResetCWCs()
		{
			for (int num = _listenCWs.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)_listenCWs[num] != (Object)null)
				{
					CustomWeaponComponent customWeaponComponent = ((Component)_listenCWs[num]).GetComponent<CustomWeaponComponent>();
					customWeaponComponent?.Clear();
					CustomWeaponData customWeaponData = GetCustomWeaponData(((ItemEquippable)_listenCWs[num]).ArchetypeID);
					if (customWeaponData != null)
					{
						if ((Object)(object)customWeaponComponent == (Object)null)
						{
							customWeaponComponent = ((Component)_listenCWs[num]).gameObject.AddComponent<CustomWeaponComponent>();
						}
						customWeaponComponent.Register(customWeaponData);
					}
				}
				else
				{
					_listenCWs.RemoveAt(num);
				}
			}
		}

		internal void CreateTemplate()
		{
			string text = Path.Combine(DEFINITION_PATH, "Template.json");
			if (!Directory.Exists(DEFINITION_PATH))
			{
				EWCLogger.Log("No directory detected. Creating " + text);
				Directory.CreateDirectory(DEFINITION_PATH);
			}
			if (File.Exists(text))
			{
				EWCLogger.Error("Can't create template file (already exists)!");
				return;
			}
			StreamWriter streamWriter = File.CreateText(text);
			streamWriter.WriteLine(EWCJson.Serialize(new List<CustomWeaponData> { CustomWeaponTemplate.CreateTemplate() }));
			streamWriter.Flush();
			streamWriter.Close();
		}

		private void PrintCustomIDs()
		{
			StringBuilder stringBuilder = new StringBuilder("Found custom blocks for archetype IDs: ");
			stringBuilder.AppendJoin(", ", _customData.Keys.ToImmutableSortedSet());
			EWCLogger.Log(stringBuilder.ToString());
		}

		private CustomWeaponManager()
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			DEFINITION_PATH = Path.Combine(MTFOPathAPI.CustomPath, "ExtraWeaponCustomization");
			if (!Directory.Exists(DEFINITION_PATH))
			{
				CreateTemplate();
			}
			else
			{
				EWCLogger.Log("Directory detected. " + DEFINITION_PATH);
			}
			foreach (string item in Directory.EnumerateFiles(DEFINITION_PATH, "*.json", SearchOption.AllDirectories))
			{
				string content = File.ReadAllText(item);
				ReadFileContent(item, content);
			}
			PrintCustomIDs();
			_liveEditListener = LiveEdit.CreateListener(DEFINITION_PATH, "*.json", true);
			_liveEditListener.FileCreated += new LiveEditEventHandler(FileCreated);
			_liveEditListener.FileChanged += new LiveEditEventHandler(FileChanged);
			_liveEditListener.FileDeleted += new LiveEditEventHandler(FileDeleted);
		}
	}
}
namespace ExtraWeaponCustomization.CustomWeapon.WeaponContext
{
	public sealed class ContextController
	{
		private interface IContextList
		{
			bool Add(IWeaponProperty property);

			bool Remove(IWeaponProperty property);

			void Clear();

			void Invoke(IWeaponContext context, List<Exception> exceptions);
		}

		private sealed class ContextList<TContext> : IContextList where TContext : IWeaponContext
		{
			private readonly List<IWeaponProperty<TContext>> _entries;

			private readonly IContextList? _baseContextList;

			private readonly ContextController _manager;

			internal ContextList(ContextController manager)
			{
				_entries = new List<IWeaponProperty<TContext>>();
				Type baseType = typeof(TContext).BaseType;
				if (baseType != null && manager._allContextLists.ContainsKey(baseType))
				{
					_baseContextList = manager._allContextLists[baseType];
				}
				_manager = manager;
				_manager._allContextLists.Add(typeof(TContext), this);
			}

			public bool Add(IWeaponProperty property)
			{
				IWeaponProperty<TContext> contextedProperty = property as IWeaponProperty<TContext>;
				if (contextedProperty == null)
				{
					return false;
				}
				if (_entries.Contains(contextedProperty))
				{
					return false;
				}
				if (!property.AllowStack && _entries.Any((IWeaponProperty<TContext> containedProperty) => containedProperty.GetType() == contextedProperty.GetType()))
				{
					return false;
				}
				_entries.Add(contextedProperty);
				return true;
			}

			public bool Remove(IWeaponProperty property)
			{
				if (property is IWeaponProperty<TContext> item)
				{
					return _entries.Remove(item);
				}
				return false;
			}

			public void Clear()
			{
				_entries.Clear();
			}

			public void Invoke(TContext context, List<Exception> exceptions)
			{
				foreach (IWeaponProperty<TContext> entry in _entries)
				{
					try
					{
						entry.Invoke(context);
					}
					catch (Exception item)
					{
						exceptions.Add(item);
					}
				}
				_baseContextList?.Invoke(context, exceptions);
			}

			void IContextList.Invoke(IWeaponContext context, List<Exception> exceptions)
			{
				if (context is TContext)
				{
					TContext context2 = (TContext)context;
					Invoke(context2, exceptions);
				}
			}
		}

		private readonly Dictionary<Type, IContextList> _allContextLists = new Dictionary<Type, IContextList>();

		public ContextController()
		{
			RegisterAllContexts();
		}

		public void Register(IWeaponProperty property)
		{
			if (property == null)
			{
				throw new ArgumentNullException("property");
			}
			foreach (IContextList value in _allContextLists.Values)
			{
				value.Add(property);
			}
		}

		public void Unregister(IWeaponProperty property)
		{
			foreach (IContextList value in _allContextLists.Values)
			{
				value.Remove(property);
			}
		}

		public void Clear()
		{
			foreach (IContextList value in _allContextLists.Values)
			{
				value.Clear();
			}
		}

		internal void Invoke<TContext>(TContext context) where TContext : IWeaponContext
		{
			if (!_allContextLists.TryGetValue(typeof(TContext), out IContextList value))
			{
				return;
			}
			List<Exception> list = new List<Exception>();
			value.Invoke(context, list);
			foreach (Exception item in list)
			{
				EWCLogger.Error(item.Message);
			}
		}

		internal void RegisterContext<TContext>() where TContext : IWeaponContext
		{
			_allContextLists.TryAdd(typeof(TContext), new ContextList<TContext>(this));
		}

		private void RegisterAllContexts()
		{
			RegisterContext<WeaponTriggerContext>();
			RegisterContext<WeaponDamageTypeContext>();
			RegisterContext<WeaponPostKillContext>();
			RegisterContext<WeaponPostFireContext>();
			RegisterContext<WeaponPreHitContext>();
			RegisterContext<WeaponPreHitEnemyContext>();
			RegisterContext<WeaponPostReloadContext>();
			RegisterContext<WeaponWieldContext>();
			RegisterContext<WeaponArmorContext>();
			RegisterContext<WeaponBackstabContext>();
			RegisterContext<WeaponCancelFireContext>();
			RegisterContext<WeaponDamageContext>();
			RegisterContext<WeaponPostAmmoInitContext>();
			RegisterContext<WeaponPreAmmoPackContext>();
			RegisterContext<WeaponPostAmmoPackContext>();
			RegisterContext<WeaponPreAmmoUIContext>();
			RegisterContext<WeaponFireRateContext>();
			RegisterContext<WeaponFireRateSetContext>();
			RegisterContext<WeaponPierceContext>();
			RegisterContext<WeaponPreFireContext>();
			RegisterContext<WeaponPreStartFireContext>();
			RegisterContext<WeaponPostStartFireContext>();
			RegisterContext<WeaponPreRayContext>();
			RegisterContext<WeaponPostRayContext>();
			RegisterContext<WeaponPostStopFiringContext>();
			RegisterContext<WeaponRecoilContext>();
			RegisterContext<WeaponClearContext>();
			RegisterContext<WeaponPostSetupContext>();
		}

		internal void ChangeToSyncContexts()
		{
			_allContextLists.Clear();
			RegisterContext<WeaponFireRateContext>();
			RegisterContext<WeaponFireRateSetContext>();
			RegisterContext<WeaponFireRateModContextSync>();
			RegisterContext<WeaponPreFireContextSync>();
			RegisterContext<WeaponPostFireContextSync>();
		}
	}
	public interface IWeaponContext
	{
		BulletWeapon Weapon { get; }
	}
}
namespace ExtraWeaponCustomization.CustomWeapon.WeaponContext.Contexts
{
	public class WeaponPostAmmoInitContext : IWeaponContext
	{
		public PlayerAmmoStorage AmmoStorage { get; set; }

		public InventorySlotAmmo SlotAmmo { get; set; }

		public BulletWeapon Weapon { get; }

		public WeaponPostAmmoInitContext(PlayerAmmoStorage ammoStorage, InventorySlotAmmo slotAmmo, BulletWeapon weapon)
		{
			AmmoStorage = ammoStorage;
			SlotAmmo = slotAmmo;
			Weapon = weapon;
		}
	}
	public class WeaponPostAmmoPackContext : IWeaponContext
	{
		public PlayerAmmoStorage AmmoStorage { get; set; }

		public BulletWeapon Weapon { get; }

		public WeaponPostAmmoPackContext(PlayerAmmoStorage ammoStorage, BulletWeapon weapon)
		{
			AmmoStorage = ammoStorage;
			Weapon = weapon;
		}
	}
	public class WeaponPreAmmoPackContext : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public float AmmoRel { get; set; }

		public WeaponPreAmmoPackContext(BulletWeapon weapon, float ammoRel)
		{
			Weapon = weapon;
			AmmoRel = ammoRel;
		}
	}
	public class WeaponPreAmmoUIContext : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public int Clip { get; set; }

		public int Reserve { get; set; }

		public float TotalRel { get; set; }

		public bool ShowClip { get; set; }

		public bool ShowReserve { get; set; }

		public bool ShowRel { get; set; }

		public bool ShowInfinite { get; set; }

		public WeaponPreAmmoUIContext(BulletWeapon weapon, int clip, int reserve, float totalRel, bool showClip, bool showReserve, bool showRel, bool showInfinite)
		{
			Weapon = weapon;
			Clip = clip;
			Reserve = reserve;
			TotalRel = totalRel;
			ShowClip = showClip;
			ShowReserve = showReserve;
			ShowRel = showRel;
			ShowInfinite = showInfinite;
		}
	}
	public sealed class WeaponArmorContext : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public float ArmorMulti { get; set; }

		public WeaponArmorContext(float armor, BulletWeapon weapon)
		{
			ArmorMulti = armor;
			Weapon = weapon;
		}
	}
	public sealed class WeaponCancelFireContext : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public WeaponCancelFireContext(BulletWeapon weapon)
		{
			Weapon = weapon;
		}
	}
	public sealed class WeaponPostRayContext : IWeaponContext
	{
		public WeaponHitData Data { get; }

		public BulletWeapon Weapon { get; }

		public Vector3 Position { get; }

		public bool Result { get; set; }

		public WeaponPostRayContext(WeaponHitData weaponHitData, Vector3 position, BulletWeapon weapon, bool result)
		{
			//IL_0015: 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)
			Data = weaponHitData;
			Weapon = weapon;
			Position = position;
			Result = result;
		}
	}
	public sealed class WeaponPostStartFireContext : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public WeaponPostStartFireContext(BulletWeapon weapon)
		{
			Weapon = weapon;
		}
	}
	public sealed class WeaponPostStopFiringContext : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public WeaponPostStopFiringContext(BulletWeapon weapon)
		{
			Weapon = weapon;
		}
	}
	public sealed class WeaponPreFireContext : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public bool Allow { get; set; }

		public WeaponPreFireContext(BulletWeapon weapon)
		{
			Weapon = weapon;
			Allow = true;
		}
	}
	public sealed class WeaponPreRayContext : IWeaponContext
	{
		public WeaponHitData Data { get; }

		public BulletWeapon Weapon { get; }

		public Vector3 Position { get; }

		public WeaponPreRayContext(WeaponHitData weaponHitData, Vector3 position, BulletWeapon weapon)
		{
			//IL_0015: 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)
			Data = weaponHitData;
			Weapon = weapon;
			Position = position;
		}
	}
	public class WeaponPreStartFireContext : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public bool Allow { get; set; }

		public WeaponPreStartFireContext(BulletWeapon weapon)
		{
			Weapon = weapon;
			Allow = true;
		}
	}
	public sealed class StackMod
	{
		private readonly float _value;

		private float _min;

		private float _addMod = 1f;

		private float _multMod = 1f;

		private float _overrideMod = -1f;

		public float Value => Math.Max(_min, _value * ((_overrideMod >= 0f) ? _overrideMod : (_addMod * _multMod)));

		public StackMod(float value, float min = 0f)
		{
			_value = value;
			_min = min;
		}

		public void SetMin(float min)
		{
			_min = min;
		}

		public void AddMod(float mod, StackType type)
		{
			switch (type)
			{
			case StackType.Override:
				_overrideMod = mod;
				break;
			case StackType.Add:
				_addMod += mod - 1f;
				break;
			case StackType.Multiply:
				_multMod *= mod;
				break;
			}
		}
	}
	internal class WeaponBackstabContext : WeaponStackModContext
	{
		public WeaponBackstabContext(BulletWeapon weapon)
			: base(2f, weapon)
		{
			_stackMod.SetMin(1f);
		}
	}
	public sealed class WeaponDamageContext : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public IDamageable Damageable { get; }

		public StackMod Damage { get; }

		public StackMod Precision { get; }

		public WeaponDamageContext(float damage, float precision, IDamageable damageable, BulletWeapon weapon)
		{
			Weapon = weapon;
			Damage = new StackMod(damage);
			Precision = new StackMod(precision);
			Damageable = damageable;
		}
	}
	public class WeaponFireRateContext : WeaponStackModContext
	{
		public WeaponFireRateContext(float fireRate, BulletWeapon weapon)
			: base(fireRate, weapon)
		{
		}
	}
	public class WeaponFireRateSetContext : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public float FireRate { get; set; }

		public WeaponFireRateSetContext(BulletWeapon weapon, float fireRate)
		{
			Weapon = weapon;
			FireRate = fireRate;
		}
	}
	public sealed class WeaponPierceContext : WeaponStackModContext
	{
		public IDamageable Damageable { get; }

		public WeaponPierceContext(float damage, IDamageable damageable, BulletWeapon weapon)
			: base(damage, weapon)
		{
			Damageable = damageable;
		}
	}
	public class WeaponRecoilContext : WeaponStackModContext
	{
		public WeaponRecoilContext(BulletWeapon weapon)
			: base(1f, weapon)
		{
			_stackMod.SetMin(float.MinValue);
		}
	}
	public abstract class WeaponStackModContext : IWeaponContext
	{
		protected readonly StackMod _stackMod;

		public BulletWeapon Weapon { get; }

		public float Value => _stackMod.Value;

		public WeaponStackModContext(float value, BulletWeapon weapon)
		{
			_stackMod = new StackMod(value);
			Weapon = weapon;
		}

		public void AddMod(float mod, StackType type)
		{
			_stackMod.AddMod(mod, type);
		}
	}
	public sealed class WeaponClearContext : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public WeaponClearContext(BulletWeapon weapon)
		{
			Weapon = weapon;
		}
	}
	public sealed class WeaponPostSetupContext : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public WeaponPostSetupContext(BulletWeapon weapon)
		{
			Weapon = weapon;
		}
	}
	public sealed class WeaponFireRateModContextSync : IWeaponContext
	{
		public float Mod { get; }

		public BulletWeapon Weapon { get; }

		public WeaponFireRateModContextSync(float mod, BulletWeapon weapon)
		{
			Mod = mod;
			Weapon = weapon;
		}
	}
	public sealed class WeaponPostFireContextSync : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public WeaponPostFireContextSync(BulletWeapon weapon)
		{
			Weapon = weapon;
		}
	}
	public sealed class WeaponPreFireContextSync : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public WeaponPreFireContextSync(BulletWeapon weapon)
		{
			Weapon = weapon;
		}
	}
	[Flags]
	public enum DamageType
	{
		Invalid = -1,
		Any = 0,
		Weakspot = 1,
		Bullet = 2,
		WeakspotBullet = 3,
		Explosive = 4,
		WeakspotExplosive = 5,
		DOT = 8,
		WeakspotDOT = 9
	}
	public abstract class WeaponDamageTypeContext : WeaponTriggerContext
	{
		public DamageType DamageType { get; protected set; }

		public WeaponDamageTypeContext(BulletWeapon weapon, DamageType flag)
			: base(weapon)
		{
			DamageType = flag;
		}
	}
	public sealed class WeaponPostFireContext : WeaponTriggerContext
	{
		public WeaponPostFireContext(BulletWeapon weapon)
			: base(weapon)
		{
		}
	}
	public sealed class WeaponPostKillContext : WeaponDamageTypeContext
	{
		public Vector3 Position { get; }

		public Vector3 Direction { get; }

		public Vector3 LocalPosition { get; }

		public EnemyAgent Enemy { get; }

		public float Falloff { get; }

		public float Backstab { get; }

		public WeaponPostKillContext(WeaponPreHitEnemyContext hitContext)
			: base(hitContext.Weapon, hitContext.DamageType)
		{
			//IL_002a: 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_003f: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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)
			Enemy = ((Il2CppObjectBase)hitContext.Damageable.GetBaseAgent()).TryCast<EnemyAgent>();
			Position = hitContext.LocalPosition + Enemy.Position;
			Direction = hitContext.Direction;
			LocalPosition = hitContext.LocalPosition;
			Falloff = hitContext.Falloff;
			Backstab = hitContext.Backstab;
		}
	}
	public class WeaponPostReloadContext : WeaponTriggerContext
	{
		public WeaponPostReloadContext(BulletWeapon weapon)
			: base(weapon)
		{
		}
	}
	public class WeaponPreHitContext : WeaponDamageTypeContext
	{
		public Vector3 Position { get; }

		public Vector3 Direction { get; }

		public float Falloff { get; }

		public Vector3 LocalPosition { get; }

		public IDamageable? Damageable { get; }

		public WeaponPreHitContext(Vector3 position, Vector3 direction, float falloff, BulletWeapon weapon, IDamageable? damageable = null)
			: base(weapon, DamageType.Bullet)
		{
			//IL_000a: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			Position = position;
			Direction = direction;
			Falloff = falloff;
			Vector3? val = ((damageable != null) ? new Vector3?(damageable.GetBaseAgent().Position) : null);
			LocalPosition = (Vector3)(((??)(val.HasValue ? new Vector3?(position - val.GetValueOrDefault()) : null)) ?? Vector3.zero);
			Damageable = damageable;
		}

		public WeaponPreHitContext(WeaponHitData data, float additionalDist, BulletWeapon weapon, IDamageable? damageable = null)
		{
			//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)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit rayHit = data.rayHit;
			Vector3 point = ((RaycastHit)(ref rayHit)).point;
			Vector3 fireDir = data.fireDir;
			this..ctor(point, ((Vector3)(ref fireDir)).normalized, data.Falloff(additionalDist), weapon, damageable);
		}
	}
	public sealed class WeaponPreHitEnemyContext : WeaponPreHitContext
	{
		public float Damage { get; }

		public float Backstab { get; }

		public new IDamageable Damageable => base.Damageable;

		public WeaponPreHitEnemyContext(float damage, float falloff, float backstab, IDamageable damageable, Vector3 position, Vector3 direction, BulletWeapon weapon, DamageType flag = DamageType.Any)
			: base(position, direction, falloff, weapon, damageable)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			Damage = damage;
			IDamageable baseDamagable = damageable.GetBaseDamagable();
			Dam_EnemyDamageBase val = ((baseDamagable != null) ? ((Il2CppObjectBase)baseDamagable).TryCast<Dam_EnemyDamageBase>() : null);
			if ((Object)(object)val != (Object)null)
			{
				Damage = Math.Min(Damage, ((Dam_SyncedDamageBase)val).HealthMax);
			}
			Backstab = backstab;
			base.DamageType = flag;
		}

		public WeaponPreHitEnemyContext(WeaponHitData data, float additionalDist, float backstab, Dam_EnemyDamageLimb limb, BulletWeapon weapon, DamageType flag = DamageType.Any)
			: base(data, additionalDist, weapon, ((Il2CppObjectBase)limb).TryCast<IDamageable>())
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Invalid comparison between Unknown and I4
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Invalid comparison between Unknown and I4
			Backstab = backstab;
			Damage = data.damage * base.Falloff;
			Damage = limb.ApplyWeakspotAndArmorModifiers(Damage, data.precisionMulti);
			Damage *= Backstab;
			Damage = Math.Min(Damage, ((Dam_SyncedDamageBase)limb.m_base).HealthMax);
			if ((int)limb.DestructionType == 1)
			{
				Damage = Math.Min(Damage, limb.m_healthMax);
			}
			base.DamageType = flag;
			if ((int)limb.m_type == 1)
			{
				base.DamageType |= DamageType.Weakspot;
			}
		}
	}
	public abstract class WeaponTriggerContext : IWeaponContext
	{
		public BulletWeapon Weapon { get; }

		public WeaponTriggerContext(BulletWeapon weapon)
		{
			Weapon = weapon;
		}
	}
	public class WeaponWieldContext : WeaponTriggerContext
	{
		public WeaponWieldContext(BulletWeapon weapon)
			: base(weapon)
		{
		}
	}
}
namespace ExtraWeaponCustomization.CustomWeapon.Properties
{
	public interface IWeaponProperty
	{
		bool AllowStack { get; }

		IWeaponProperty Clone();

		void Serialize(Utf8JsonWriter writer, JsonSerializerOptions options);

		void DeserializeProperty(string property, ref Utf8JsonReader reader, JsonSerializerOptions options);
	}
	public interface IWeaponProperty<TContext> : IWeaponProperty where TContext : IWeaponContext
	{
		void Invoke(TContext context);
	}
}
namespace ExtraWeaponCustomization.CustomWeapon.Properties.Traits
{
	public class AmmoCap : Trait, IWeaponProperty<WeaponPostSetupContext>, IWeaponProperty, IWeaponProperty<WeaponPostAmmoInitContext>, IWeaponProperty<WeaponPreAmmoPackContext>
	{
		private const float DefaultPackConv = 5f;

		public float AmmoCapRel { get; set; } = 1f;


		public float AmmopackRefillRel { get; set; }

		public float CostOfBullet { get; set; }

		public void Invoke(WeaponPostSetupContext context)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_002b: Invalid comparison between Unknown and I4
			if (AmmopackRefillRel > 0f)
			{
				PlayerDataBlock block = GameDataBlockBase<PlayerDataBlock>.GetBlock(1u);
				float num = 1f;
				AmmoType ammoType = ((ItemEquippable)context.Weapon).AmmoType;
				if ((int)ammoType != 0)
				{
					if ((int)ammoType == 1)
					{
						num = (float)block.AmmoSpecialMaxCap / (float)block.AmmoSpecialResourcePackMaxCap;
					}
				}
				else
				{
					num = (float)block.AmmoStandardMaxCap / (float)block.AmmoStandardResourcePackMaxCap;
				}
				AmmoCapRel = AmmopackRefillRel * 5f * num;
			}
			if (CostOfBullet > 0f)
			{
				AmmoCapRel = ((ItemEquippable)context.Weapon).ArchetypeData.CostOfBullet / CostOfBullet;
			}
		}

		public void Invoke(WeaponPostAmmoInitContext context)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			InventorySlotAmmo slotAmmo = context.SlotAmmo;
			slotAmmo.AmmoInPack = ((float)((ItemEquippable)context.Weapon).GetCurrentClip() * slotAmmo.CostOfBullet + slotAmmo.AmmoInPack) * AmmoCapRel;
			((ItemEquippable)context.Weapon).SetCurrentClip(context.AmmoStorage.GetClipBulletsFromPack(0, slotAmmo.AmmoType));
		}

		public void Invoke(WeaponPreAmmoPackContext context)
		{
			context.AmmoRel *= AmmoCapRel;
		}

		public override IWeaponProperty Clone()
		{
			return new AmmoCap
			{
				AmmoCapRel = AmmoCapRel,
				AmmopackRefillRel = AmmopackRefillRel,
				CostOfBullet = CostOfBullet
			};
		}

		public override void Serialize(Utf8JsonWriter writer, JsonSerializerOptions options)
		{
			writer.WriteStartObject();
			writer.WriteString("Name", "AmmoCap");
			writer.WriteNumber("AmmoCapRel", AmmoCapRel);
			writer.WriteNumber("AmmopackRefillRel", AmmopackRefillRel);
			writer.WriteNumber("CostOfBullet", CostOfBullet);
			writer.WriteEndObject();
		}

		public override void DeserializeProperty(string property, ref Utf8JsonReader reader, JsonSerializerOptions options)
		{
			if (property == null)
			{
				return;
			}
			switch (property.Length)
			{
			default:
				return;
			case 10:
			{
				char c = property[4];
				if (c != 'c')
				{
					if (c != 'r' || !(property == "ammorefill"))
					{
						return;
					}
					break;
				}
				if (!(property == "ammocaprel"))
				{
					return;
				}
				goto IL_0101;
			}
			case 6:
			{
				char c = property[0];
				if (c != 'c')
				{
					if (c != 'r' || !(property == "refill"))
					{
						return;
					}
					break;
				}
				if (!(property == "caprel"))
				{
					return;
				}
				goto IL_0101;
			}
			case 12:
				if (property == "costofbullet")
				{
					CostOfBullet = reader.GetSingle();
					AmmopackRefillRel = 0f;
				}
				return;
			case 7:
				if (!(property == "ammocap"))
				{
					return;
				}
				goto IL_0101;
			case 3:
				if (!(property == "cap"))
				{
					return;
				}
				goto IL_0101;
			case 13:
				if (!(property == "ammorefillrel"))
				{
					return;
				}
				break;
			case 9:
				if (!(property == "refillrel"))
				{
					return;
				}
				break;
			case 4:
			case 5:
			case 8:
			case 11:
				return;
				IL_0101:
				AmmoCapRel = reader.GetSingle();
				CostOfBullet = 0f;
				AmmopackRefillRel = 0f;
				return;
			}
			AmmopackRefillRel = reader.GetSingle();
			CostOfBullet = 0f;
		}
	}
	public sealed class ReserveClip : Trait, IWeaponProperty<WeaponPostAmmoPackContext>, IWeaponProperty, IWeaponProperty<WeaponPreAmmoUIContext>, IWeaponProperty<WeaponPostStartFireContext>, IWeaponProperty<WeaponPostFireContext>
	{
		public void Invoke(WeaponPostStartFireContext context)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((ItemEquippable)context.Weapon).ArchetypeData.FireMode == 1)
			{
				BWA_Burst obj = ((Il2CppObjectBase)context.Weapon.m_archeType).TryCast<BWA_Burst>();
				obj.m_burstCurrentCount = Math.Min(val2: ((ItemEquippable)context.Weapon).GetCurrentClip() + PlayerBackpackManager.GetBulletsInPack(((ItemEquippable)context.Weapon).AmmoType, ((Item)context.Weapon).Owner.Owner), val1: obj.m_burstMax);
			}
		}

		public void Invoke(WeaponPostAmmoPackContext context)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			BulletWeapon weapon = context.Weapon;
			if ((Object)(object)((Item)weapon).Owner.Inventory.WieldedItem != (Object)(object)context.Weapon)
			{
				((ItemEquippable)weapon).SetCurrentClip(context.AmmoStorage.GetClipBulletsFromPack(((ItemEquippable)weapon).GetCurrentClip(), ((ItemEquippable)weapon).AmmoType));
				((Weapon)weapon).m_wasOutOfAmmo = false;
			}
			else
			{
				((Item)weapon).Owner.Inventory.DoReload();
			}
		}

		public void Invoke(WeaponPostFireContext context)
		{
			((Item)context.Weapon).Owner.Inventory.DoReload();
		}

		public void Invoke(WeaponPreAmmoUIContext context)
		{
			context.Reserve += context.Clip;
			context.ShowClip = false;
		}

		public override IWeaponProperty Clone()
		{
			return new ReserveClip();
		}

		public override void Serialize(Utf8JsonWriter writer, JsonSerializerOptions options)
		{
			writer.WriteStartObject();
			writer.WriteString("Name", GetType().Name);
			writer.WriteEndObject();
		}

		public override void DeserializeProperty(string property, ref Utf8JsonReader reader, JsonSerializerOptions options)
		{
		}
	}
	public sealed class AutoAim : Trait, IWeaponProperty<WeaponPostSetupContext>, IWeaponProperty, IWeaponProperty<WeaponClearContext>, IWeaponProperty<WeaponPreStartFireContext>, IWeaponProperty<WeaponPreFireContext>, IWeaponProperty<WeaponPreRayContext>
	{
		private sealed class ColliderComparer : IComparer<Collider>
		{
			private Vector3 _forward;

			private Vector3 _position;

			public void Set(Vector3 forward, Vector3 position)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: 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_0009: Unknown result type (might be due to invalid IL or missing references)
				_forward = forward;
				_position = position;
			}

			public int Compare(Collider? x, Collider? y)
			{
				//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_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: 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)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)x == (Object)null)
				{
					return 1;
				}
				if ((Object)(object)y