Decompiled source of AI Blacklist v1.6.2

AI_Blacklist.dll

Decompiled 5 months ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using EntityStates.ScavMonster;
using On.EntityStates.ScavMonster;
using On.RoR2;
using RoR2;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("AI_Blacklist")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("AI_Blacklist")]
[assembly: AssemblyTitle("AI_Blacklist")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace R2API.Utils
{
	[AttributeUsage(AttributeTargets.Assembly)]
	public class ManualNetworkRegistrationAttribute : Attribute
	{
	}
}
namespace AI_Blacklist
{
	public class AIBlacklist
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<char, bool> <>9__2_1;

			public static hook_Init <>9__2_0;

			internal void <.ctor>b__2_0(orig_Init orig)
			{
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Invalid comparison between Unknown and I4
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke();
				if (!useVanillaAIBlacklist)
				{
					ItemDef[] itemDefs = ItemCatalog.itemDefs;
					foreach (ItemDef val in itemDefs)
					{
						if (!val.ContainsTag((ItemTag)4))
						{
							continue;
						}
						List<ItemTag> list = val.tags.ToList();
						list.Remove((ItemTag)4);
						val.tags = list.ToArray();
						ItemIndex itemIndex = val.itemIndex;
						if ((int)itemIndex != -1 && ItemCatalog.itemIndicesByTag != null && ItemCatalog.itemIndicesByTag[4] != null)
						{
							List<ItemIndex> list2 = ItemCatalog.itemIndicesByTag[4].ToList();
							if (list2.Contains(itemIndex))
							{
								list2.Remove(itemIndex);
								ItemCatalog.itemIndicesByTag[4] = list2.ToArray();
							}
						}
					}
				}
				itemBlacklistString = new string((from c in itemBlacklistString.ToCharArray()
					where !char.IsWhiteSpace(c)
					select c).ToArray());
				string[] array = itemBlacklistString.Split(new char[1] { ',' });
				string[] array2 = array;
				foreach (string itemName in array2)
				{
					AddToBlacklist(itemName);
				}
			}

			internal bool <.ctor>b__2_1(char c)
			{
				return !char.IsWhiteSpace(c);
			}
		}

		public static bool useVanillaAIBlacklist;

		public static string itemBlacklistString;

		public AIBlacklist()
		{
			//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_0027: Expected O, but got Unknown
			object obj = <>c.<>9__2_0;
			if (obj == null)
			{
				hook_Init val = delegate(orig_Init orig)
				{
					//IL_0065: Unknown result type (might be due to invalid IL or missing references)
					//IL_006a: Unknown result type (might be due to invalid IL or missing references)
					//IL_006c: Unknown result type (might be due to invalid IL or missing references)
					//IL_006f: Invalid comparison between Unknown and I4
					//IL_009c: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke();
					if (!useVanillaAIBlacklist)
					{
						ItemDef[] itemDefs = ItemCatalog.itemDefs;
						foreach (ItemDef val2 in itemDefs)
						{
							if (val2.ContainsTag((ItemTag)4))
							{
								List<ItemTag> list = val2.tags.ToList();
								list.Remove((ItemTag)4);
								val2.tags = list.ToArray();
								ItemIndex itemIndex = val2.itemIndex;
								if ((int)itemIndex != -1 && ItemCatalog.itemIndicesByTag != null && ItemCatalog.itemIndicesByTag[4] != null)
								{
									List<ItemIndex> list2 = ItemCatalog.itemIndicesByTag[4].ToList();
									if (list2.Contains(itemIndex))
									{
										list2.Remove(itemIndex);
										ItemCatalog.itemIndicesByTag[4] = list2.ToArray();
									}
								}
							}
						}
					}
					itemBlacklistString = new string((from c in itemBlacklistString.ToCharArray()
						where !char.IsWhiteSpace(c)
						select c).ToArray());
					string[] array = itemBlacklistString.Split(new char[1] { ',' });
					string[] array2 = array;
					foreach (string itemName in array2)
					{
						AddToBlacklist(itemName);
					}
				};
				<>c.<>9__2_0 = val;
				obj = (object)val;
			}
			ItemCatalog.Init += (hook_Init)obj;
		}

		public static void AddToBlacklist(string itemName)
		{
			//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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			ItemIndex val = ItemCatalog.FindItemIndex(itemName);
			if ((int)val != -1)
			{
				AddToBlacklist(val);
			}
		}

		public static void AddToBlacklist(ItemIndex index)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			//IL_005e: 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)
			ItemDef itemDef = ItemCatalog.GetItemDef(index);
			if (!itemDef.DoesNotContainTag((ItemTag)4))
			{
				return;
			}
			Array.Resize(ref itemDef.tags, itemDef.tags.Length + 1);
			itemDef.tags[itemDef.tags.Length - 1] = (ItemTag)4;
			if ((int)index != -1 && ItemCatalog.itemIndicesByTag != null)
			{
				List<ItemIndex> list = ItemCatalog.itemIndicesByTag[4].ToList();
				if (!list.Contains(index))
				{
					list.Add(index);
					ItemCatalog.itemIndicesByTag[4] = list.ToArray();
				}
			}
		}
	}
	public class AIEquipBlacklist
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<char, bool> <>9__4_1;

			public static hook_SetEquipmentIndex <>9__4_2;

			public static hook_Init <>9__4_0;

			internal void <.ctor>b__4_0(orig_Init orig)
			{
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Invalid comparison between Unknown and I4
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Expected O, but got Unknown
				orig.Invoke();
				equipBlacklist = new HashSet<EquipmentIndex>();
				equipmentBlacklistString = new string((from c in equipmentBlacklistString.ToCharArray()
					where !char.IsWhiteSpace(c)
					select c).ToArray());
				string[] array = equipmentBlacklistString.Split(new char[1] { ',' });
				string[] array2 = array;
				foreach (string text in array2)
				{
					EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex(text);
					if ((int)val != -1)
					{
						equipBlacklist.Add(val);
					}
				}
				if (equipBlacklist.Count <= 0)
				{
					return;
				}
				object obj = <>9__4_2;
				if (obj == null)
				{
					hook_SetEquipmentIndex val2 = delegate(orig_SetEquipmentIndex orig2, Inventory self, EquipmentIndex equipmentIndex)
					{
						//IL_0016: Unknown result type (might be due to invalid IL or missing references)
						//IL_001c: Invalid comparison between Unknown and I4
						//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
						//IL_0076: Unknown result type (might be due to invalid IL or missing references)
						//IL_007b: Unknown result type (might be due to invalid IL or missing references)
						//IL_007e: Unknown result type (might be due to invalid IL or missing references)
						//IL_0080: Unknown result type (might be due to invalid IL or missing references)
						//IL_008a: Unknown result type (might be due to invalid IL or missing references)
						//IL_0093: Unknown result type (might be due to invalid IL or missing references)
						//IL_0098: Unknown result type (might be due to invalid IL or missing references)
						CharacterMaster component = ((Component)self).gameObject.GetComponent<CharacterMaster>();
						if (Object.op_Implicit((Object)(object)component) && (int)component.teamIndex != 1 && component.aiComponents != null && component.aiComponents.Length != 0)
						{
							Inventory inventory = component.inventory;
							if (Object.op_Implicit((Object)(object)inventory) && inventory.GetItemCount(Items.InvadingDoppelganger) <= 0)
							{
								foreach (EquipmentIndex item in equipBlacklist)
								{
									if (item == equipmentIndex)
									{
										EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(item);
										equipmentIndex = GetRandomNonBlacklistEquipment();
										break;
									}
								}
							}
						}
						orig2.Invoke(self, equipmentIndex);
					};
					<>9__4_2 = val2;
					obj = (object)val2;
				}
				Inventory.SetEquipmentIndex += (hook_SetEquipmentIndex)obj;
			}

			internal bool <.ctor>b__4_1(char c)
			{
				return !char.IsWhiteSpace(c);
			}

			internal void <.ctor>b__4_2(orig_SetEquipmentIndex orig2, Inventory self, EquipmentIndex equipmentIndex)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Invalid comparison between Unknown and I4
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				CharacterMaster component = ((Component)self).gameObject.GetComponent<CharacterMaster>();
				if (Object.op_Implicit((Object)(object)component) && (int)component.teamIndex != 1 && component.aiComponents != null && component.aiComponents.Length != 0)
				{
					Inventory inventory = component.inventory;
					if (Object.op_Implicit((Object)(object)inventory) && inventory.GetItemCount(Items.InvadingDoppelganger) <= 0)
					{
						foreach (EquipmentIndex item in equipBlacklist)
						{
							if (item == equipmentIndex)
							{
								EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(item);
								equipmentIndex = GetRandomNonBlacklistEquipment();
								break;
							}
						}
					}
				}
				orig2.Invoke(self, equipmentIndex);
			}
		}

		public static HashSet<EquipmentIndex> equipBlacklist;

		public static HashSet<EliteDef> allowedEliteDefs;

		public static bool blacklistVengeanceEquipment;

		public static string equipmentBlacklistString;

		public AIEquipBlacklist()
		{
			//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_0027: Expected O, but got Unknown
			object obj = <>c.<>9__4_0;
			if (obj == null)
			{
				hook_Init val = delegate(orig_Init orig)
				{
					//IL_0072: Unknown result type (might be due to invalid IL or missing references)
					//IL_0077: Unknown result type (might be due to invalid IL or missing references)
					//IL_0079: Unknown result type (might be due to invalid IL or missing references)
					//IL_007c: Invalid comparison between Unknown and I4
					//IL_008d: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
					//IL_00d4: Expected O, but got Unknown
					orig.Invoke();
					equipBlacklist = new HashSet<EquipmentIndex>();
					equipmentBlacklistString = new string((from c in equipmentBlacklistString.ToCharArray()
						where !char.IsWhiteSpace(c)
						select c).ToArray());
					string[] array = equipmentBlacklistString.Split(new char[1] { ',' });
					string[] array2 = array;
					foreach (string text in array2)
					{
						EquipmentIndex val2 = EquipmentCatalog.FindEquipmentIndex(text);
						if ((int)val2 != -1)
						{
							equipBlacklist.Add(val2);
						}
					}
					if (equipBlacklist.Count > 0)
					{
						object obj2 = <>c.<>9__4_2;
						if (obj2 == null)
						{
							hook_SetEquipmentIndex val3 = delegate(orig_SetEquipmentIndex orig2, Inventory self, EquipmentIndex equipmentIndex)
							{
								//IL_0016: Unknown result type (might be due to invalid IL or missing references)
								//IL_001c: Invalid comparison between Unknown and I4
								//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
								//IL_0076: Unknown result type (might be due to invalid IL or missing references)
								//IL_007b: Unknown result type (might be due to invalid IL or missing references)
								//IL_007e: Unknown result type (might be due to invalid IL or missing references)
								//IL_0080: Unknown result type (might be due to invalid IL or missing references)
								//IL_008a: Unknown result type (might be due to invalid IL or missing references)
								//IL_0093: Unknown result type (might be due to invalid IL or missing references)
								//IL_0098: Unknown result type (might be due to invalid IL or missing references)
								CharacterMaster component = ((Component)self).gameObject.GetComponent<CharacterMaster>();
								if (Object.op_Implicit((Object)(object)component) && (int)component.teamIndex != 1 && component.aiComponents != null && component.aiComponents.Length != 0)
								{
									Inventory inventory = component.inventory;
									if (Object.op_Implicit((Object)(object)inventory) && inventory.GetItemCount(Items.InvadingDoppelganger) <= 0)
									{
										foreach (EquipmentIndex item in equipBlacklist)
										{
											if (item == equipmentIndex)
											{
												EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(item);
												equipmentIndex = GetRandomNonBlacklistEquipment();
												break;
											}
										}
									}
								}
								orig2.Invoke(self, equipmentIndex);
							};
							<>c.<>9__4_2 = val3;
							obj2 = (object)val3;
						}
						Inventory.SetEquipmentIndex += (hook_SetEquipmentIndex)obj2;
					}
				};
				<>c.<>9__4_0 = val;
				obj = (object)val;
			}
			EquipmentCatalog.Init += (hook_Init)obj;
		}

		private static IEnumerable<PickupIndex> EquipmentToPickupIndices(IEnumerable<EquipmentIndex> equipIndices)
		{
			foreach (EquipmentIndex index in equipIndices)
			{
				yield return PickupCatalog.FindPickupIndex(index);
			}
		}

		private static EquipmentIndex GetRandomNonBlacklistEquipment()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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)
			IEnumerable<PickupIndex> second = EquipmentToPickupIndices(equipBlacklist);
			List<PickupIndex> list = Run.instance?.availableEquipmentDropList.Except(second).ToList();
			if (list == null)
			{
				return (EquipmentIndex)(-1);
			}
			PickupDef pickupDef = PickupCatalog.GetPickupDef(list[Random.Range(0, list.Count)]);
			return pickupDef.equipmentIndex;
		}
	}
	public class MithrixBlacklist
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<char, bool> <>9__4_2;

			public static hook_FixedUpdate <>9__4_1;

			internal bool <.ctor>b__4_2(char c)
			{
				return !char.IsWhiteSpace(c);
			}

			internal void <.ctor>b__4_1(orig_FixedUpdate orig, ItemStealController self)
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				if (!Object.op_Implicit((Object)(object)self.lendeeInventory))
				{
					return;
				}
				foreach (KeyValuePair<ItemIndex, int> mithrixItemLimit in mithrixItemLimits)
				{
					int itemCount = self.lendeeInventory.GetItemCount(mithrixItemLimit.Key);
					if (itemCount > mithrixItemLimit.Value)
					{
						self.lendeeInventory.RemoveItem(mithrixItemLimit.Key, itemCount - mithrixItemLimit.Value);
					}
				}
			}
		}

		public static bool useVanillaMithrixBlacklist = true;

		public static Dictionary<ItemIndex, int> mithrixItemLimits;

		public static string mithrixBlacklistString;

		public static bool blacklistAllItems = false;

		public MithrixBlacklist()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			mithrixItemLimits = new Dictionary<ItemIndex, int>();
			ItemCatalog.Init += (hook_Init)delegate(orig_Init orig)
			{
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Invalid comparison between Unknown and I4
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0180: Unknown result type (might be due to invalid IL or missing references)
				//IL_0182: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Invalid comparison between Unknown and I4
				//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f8: Invalid comparison between Unknown and I4
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0196: Unknown result type (might be due to invalid IL or missing references)
				//IL_0206: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke();
				if (!useVanillaMithrixBlacklist)
				{
					ItemDef[] itemDefs = ItemCatalog.itemDefs;
					foreach (ItemDef val2 in itemDefs)
					{
						if (val2.ContainsTag((ItemTag)11))
						{
							List<ItemTag> list = val2.tags.ToList();
							list.Remove((ItemTag)11);
							val2.tags = list.ToArray();
							ItemIndex itemIndex = val2.itemIndex;
							if ((int)itemIndex != -1 && ItemCatalog.itemIndicesByTag != null && ItemCatalog.itemIndicesByTag[11] != null)
							{
								List<ItemIndex> list2 = ItemCatalog.itemIndicesByTag[11].ToList();
								if (list2.Contains(itemIndex))
								{
									list2.Remove(itemIndex);
									ItemCatalog.itemIndicesByTag[11] = list2.ToArray();
								}
							}
						}
					}
				}
				mithrixBlacklistString = new string((from c in mithrixBlacklistString.ToCharArray()
					where !char.IsWhiteSpace(c)
					select c).ToArray());
				string[] array = mithrixBlacklistString.Split(new char[1] { ',' });
				string[] array2 = array;
				foreach (string text in array2)
				{
					string[] array3 = text.Split(new char[1] { '-' });
					if (array3.Length == 2 && int.TryParse(array3[1], out var result) && result > 0)
					{
						ItemIndex val3 = ItemCatalog.FindItemIndex(array3[0]);
						if ((int)val3 != -1)
						{
							mithrixItemLimits.Add(val3, result);
						}
					}
					else if (array3.Length != 0)
					{
						AddToMithrixBlacklist(array3[0]);
					}
				}
				if (blacklistAllItems)
				{
					ItemDef[] itemDefs2 = ItemCatalog.itemDefs;
					foreach (ItemDef val4 in itemDefs2)
					{
						if ((int)val4.itemIndex != -1)
						{
							AddToMithrixBlacklist(val4.itemIndex);
						}
					}
				}
			};
			object obj = <>c.<>9__4_1;
			if (obj == null)
			{
				hook_FixedUpdate val = delegate(orig_FixedUpdate orig, ItemStealController self)
				{
					//IL_0038: Unknown result type (might be due to invalid IL or missing references)
					//IL_005c: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					if (Object.op_Implicit((Object)(object)self.lendeeInventory))
					{
						foreach (KeyValuePair<ItemIndex, int> mithrixItemLimit in mithrixItemLimits)
						{
							int itemCount = self.lendeeInventory.GetItemCount(mithrixItemLimit.Key);
							if (itemCount > mithrixItemLimit.Value)
							{
								self.lendeeInventory.RemoveItem(mithrixItemLimit.Key, itemCount - mithrixItemLimit.Value);
							}
						}
					}
				};
				<>c.<>9__4_1 = val;
				obj = (object)val;
			}
			ItemStealController.FixedUpdate += (hook_FixedUpdate)obj;
		}

		public void AddToMithrixBlacklist(string itemName)
		{
			//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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			ItemIndex val = ItemCatalog.FindItemIndex(itemName);
			if ((int)val != -1)
			{
				AddToMithrixBlacklist(val);
			}
		}

		public static void AddToMithrixBlacklist(ItemIndex index)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			//IL_0061: 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)
			ItemDef itemDef = ItemCatalog.GetItemDef(index);
			if (!itemDef.DoesNotContainTag((ItemTag)11))
			{
				return;
			}
			Array.Resize(ref itemDef.tags, itemDef.tags.Length + 1);
			itemDef.tags[itemDef.tags.Length - 1] = (ItemTag)11;
			if ((int)index != -1 && ItemCatalog.itemIndicesByTag != null)
			{
				List<ItemIndex> list = ItemCatalog.itemIndicesByTag[11].ToList();
				if (!list.Contains(index))
				{
					list.Add(index);
					ItemCatalog.itemIndicesByTag[11] = list.ToArray();
				}
			}
		}
	}
	public class ScavengerBlacklist
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<char, bool> <>9__3_3;

			public static hook_Init <>9__3_0;

			public static hook_Start <>9__3_1;

			public static hook_PickupIsNonBlacklistedItem <>9__3_2;

			internal void <.ctor>b__3_0(orig_Init orig)
			{
				orig.Invoke();
				scavBlacklistString = new string((from c in scavBlacklistString.ToCharArray()
					where !char.IsWhiteSpace(c)
					select c).ToArray());
				string[] array = scavBlacklistString.Split(new char[1] { ',' });
				string[] array2 = array;
				foreach (string itemName in array2)
				{
					AddToBlacklist(itemName);
				}
			}

			internal bool <.ctor>b__3_3(char c)
			{
				return !char.IsWhiteSpace(c);
			}

			internal void <.ctor>b__3_1(orig_Start orig, ScavengerItemGranter self)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Invalid comparison between Unknown and I4
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				Inventory component = ((Component)self).GetComponent<Inventory>();
				StackRollData[] stackRollDataList = self.stackRollDataList;
				foreach (StackRollData val in stackRollDataList)
				{
					if (!Object.op_Implicit((Object)(object)val.dropTable))
					{
						continue;
					}
					for (int j = 0; j < val.numRolls; j++)
					{
						PickupDef pickupDef = PickupCatalog.GetPickupDef(val.dropTable.GenerateDrop(ScavengerItemGranter.rng));
						List<ItemIndex> itemList = ((IEnumerable<ItemIndex>)Run.instance.availableItems).Where(IsNonBlacklistedItem).ToList();
						itemList = SelectItemTier(itemList, pickupDef.itemTier);
						if (itemList.Count > 0)
						{
							int index = ScavengerItemGranter.rng.RangeInt(0, itemList.Count);
							component.GiveItem(itemList[index], val.stacks);
						}
					}
				}
				if (self.overwriteEquipment || (int)component.currentEquipmentIndex == -1)
				{
					component.GiveRandomEquipment(ScavengerItemGranter.rng);
				}
			}

			internal bool <.ctor>b__3_2(orig_PickupIsNonBlacklistedItem orig, FindItem self, PickupIndex pickupIndex)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return PickupIsNonBlacklistedItem(pickupIndex);
			}
		}

		public static bool useScavBlacklist;

		public static string scavBlacklistString;

		public static HashSet<ItemDef> scavBlacklist;

		public ScavengerBlacklist()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//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_0064: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			if (!useScavBlacklist)
			{
				return;
			}
			scavBlacklist = new HashSet<ItemDef>();
			object obj = <>c.<>9__3_0;
			if (obj == null)
			{
				hook_Init val = delegate(orig_Init orig)
				{
					orig.Invoke();
					scavBlacklistString = new string((from c in scavBlacklistString.ToCharArray()
						where !char.IsWhiteSpace(c)
						select c).ToArray());
					string[] array = scavBlacklistString.Split(new char[1] { ',' });
					string[] array2 = array;
					foreach (string itemName in array2)
					{
						AddToBlacklist(itemName);
					}
				};
				<>c.<>9__3_0 = val;
				obj = (object)val;
			}
			ItemCatalog.Init += (hook_Init)obj;
			object obj2 = <>c.<>9__3_1;
			if (obj2 == null)
			{
				hook_Start val2 = delegate(orig_Start orig, ScavengerItemGranter self)
				{
					//IL_0019: Unknown result type (might be due to invalid IL or missing references)
					//IL_001e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0020: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00fb: Invalid comparison between Unknown and I4
					//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
					//IL_003e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0049: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
					Inventory component = ((Component)self).GetComponent<Inventory>();
					StackRollData[] stackRollDataList = self.stackRollDataList;
					foreach (StackRollData val4 in stackRollDataList)
					{
						if (Object.op_Implicit((Object)(object)val4.dropTable))
						{
							for (int j = 0; j < val4.numRolls; j++)
							{
								PickupDef pickupDef = PickupCatalog.GetPickupDef(val4.dropTable.GenerateDrop(ScavengerItemGranter.rng));
								List<ItemIndex> itemList = ((IEnumerable<ItemIndex>)Run.instance.availableItems).Where(IsNonBlacklistedItem).ToList();
								itemList = SelectItemTier(itemList, pickupDef.itemTier);
								if (itemList.Count > 0)
								{
									int index = ScavengerItemGranter.rng.RangeInt(0, itemList.Count);
									component.GiveItem(itemList[index], val4.stacks);
								}
							}
						}
					}
					if (self.overwriteEquipment || (int)component.currentEquipmentIndex == -1)
					{
						component.GiveRandomEquipment(ScavengerItemGranter.rng);
					}
				};
				<>c.<>9__3_1 = val2;
				obj2 = (object)val2;
			}
			ScavengerItemGranter.Start += (hook_Start)obj2;
			object obj3 = <>c.<>9__3_2;
			if (obj3 == null)
			{
				hook_PickupIsNonBlacklistedItem val3 = (orig_PickupIsNonBlacklistedItem orig, FindItem self, PickupIndex pickupIndex) => PickupIsNonBlacklistedItem(pickupIndex);
				<>c.<>9__3_2 = val3;
				obj3 = (object)val3;
			}
			FindItem.PickupIsNonBlacklistedItem += (hook_PickupIsNonBlacklistedItem)obj3;
		}

		private static List<ItemIndex> SelectItemTier(List<ItemIndex> itemList, ItemTier tier)
		{
			//IL_0013: 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)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			//IL_0039: 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_006e: 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)
			List<ItemIndex> list = new List<ItemIndex>();
			foreach (ItemIndex item in itemList)
			{
				ItemDef itemDef = ItemCatalog.GetItemDef(item);
				if (itemDef.tier != tier || (int)item == -1)
				{
					list.Add(item);
				}
			}
			foreach (ItemIndex item2 in list)
			{
				itemList.Remove(item2);
			}
			return itemList;
		}

		public static bool IsNonBlacklistedItem(ItemIndex itemIndex)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ItemDef itemDef = ItemCatalog.GetItemDef(itemIndex);
			return !((Object)(object)itemDef == (Object)null) && !scavBlacklist.Contains(itemDef);
		}

		public static bool PickupIsNonBlacklistedItem(PickupIndex pickupIndex)
		{
			//IL_0001: 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)
			PickupDef pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
			if (pickupDef == null)
			{
				return false;
			}
			ItemDef itemDef = ItemCatalog.GetItemDef(pickupDef.itemIndex);
			return !((Object)(object)itemDef == (Object)null) && !scavBlacklist.Contains(itemDef);
		}

		public static void AddToBlacklist(string itemName)
		{
			//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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			ItemIndex val = ItemCatalog.FindItemIndex(itemName);
			if ((int)val != -1)
			{
				AddToBlacklist(val);
			}
		}

		public static void AddToBlacklist(ItemIndex index)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ItemDef itemDef = ItemCatalog.GetItemDef(index);
			scavBlacklist.Add(itemDef);
		}
	}
	public class VengeanceBlacklist
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<char, bool> <>9__5_1;

			public static hook_Init <>9__5_0;

			internal void <.ctor>b__5_0(orig_Init orig)
			{
				orig.Invoke();
				vengeanceItemBlacklist = new HashSet<ItemIndex>();
				vengeanceItemBlacklistString = new string((from c in vengeanceItemBlacklistString.ToCharArray()
					where !char.IsWhiteSpace(c)
					select c).ToArray());
				string[] array = vengeanceItemBlacklistString.Split(new char[1] { ',' });
				string[] array2 = array;
				foreach (string itemName in array2)
				{
					AddToVengeanceBlacklist(itemName);
				}
			}

			internal bool <.ctor>b__5_1(char c)
			{
				return !char.IsWhiteSpace(c);
			}
		}

		public static bool fixVengeanceScaling = true;

		public static string vengeanceItemBlacklistString;

		public static HashSet<ItemIndex> vengeanceItemBlacklist;

		public static bool useAIBlacklist = true;

		public static bool useTurretBlacklist = true;

		public VengeanceBlacklist()
		{
			//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_0027: Expected O, but got Unknown
			object obj = <>c.<>9__5_0;
			if (obj == null)
			{
				hook_Init val = delegate(orig_Init orig)
				{
					orig.Invoke();
					vengeanceItemBlacklist = new HashSet<ItemIndex>();
					vengeanceItemBlacklistString = new string((from c in vengeanceItemBlacklistString.ToCharArray()
						where !char.IsWhiteSpace(c)
						select c).ToArray());
					string[] array = vengeanceItemBlacklistString.Split(new char[1] { ',' });
					string[] array2 = array;
					foreach (string itemName in array2)
					{
						AddToVengeanceBlacklist(itemName);
					}
				};
				<>c.<>9__5_0 = val;
				obj = (object)val;
			}
			ItemCatalog.Init += (hook_Init)obj;
			if (fixVengeanceScaling || vengeanceItemBlacklist.Count > 0 || useAIBlacklist || useTurretBlacklist)
			{
				CharacterMaster.onStartGlobal += RunVengeanceChanges;
			}
		}

		private void RunVengeanceChanges(CharacterMaster self)
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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_0104: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active || !Object.op_Implicit((Object)(object)self.inventory) || self.inventory.GetItemCount(Items.InvadingDoppelganger) <= 0)
			{
				return;
			}
			if (fixVengeanceScaling)
			{
				int itemCount = self.inventory.GetItemCount(Items.UseAmbientLevel);
				if (itemCount > 0)
				{
					self.inventory.RemoveItem(Items.UseAmbientLevel, itemCount);
				}
				int itemCount2 = self.inventory.GetItemCount(Items.LevelBonus);
				if (itemCount2 > 0)
				{
					self.inventory.RemoveItem(Items.LevelBonus, itemCount2);
				}
				self.inventory.GiveItem(Items.LevelBonus, (int)(TeamManager.instance.GetTeamLevel((TeamIndex)1) - 1));
			}
			if (vengeanceItemBlacklist.Count > 0)
			{
				foreach (ItemIndex item in vengeanceItemBlacklist)
				{
					int itemCount3 = self.inventory.GetItemCount(item);
					if (itemCount3 > 0)
					{
						self.inventory.RemoveItem(item, itemCount3);
					}
				}
			}
			if (!useAIBlacklist && !useTurretBlacklist)
			{
				return;
			}
			ItemDef[] itemDefs = ItemCatalog.itemDefs;
			foreach (ItemDef val in itemDefs)
			{
				if ((useAIBlacklist && val.ContainsTag((ItemTag)4)) || (useTurretBlacklist && val.ContainsTag((ItemTag)13)))
				{
					int itemCount4 = self.inventory.GetItemCount(val);
					if (itemCount4 > 0)
					{
						self.inventory.RemoveItem(val, itemCount4);
					}
				}
			}
		}

		public static void AddToVengeanceBlacklist(string itemName)
		{
			//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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			ItemIndex val = ItemCatalog.FindItemIndex(itemName);
			if ((int)val != -1)
			{
				AddToVengeanceBlacklist(val);
			}
		}

		public static void AddToVengeanceBlacklist(ItemIndex item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			vengeanceItemBlacklist.Add(item);
		}
	}
	[BepInPlugin("com.Moffein.AI_Blacklist", "AI Blacklist", "1.6.2")]
	public class AI_Blacklist : BaseUnityPlugin
	{
		public void ReadConfig()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_002c: Expected O, but got Unknown
			//IL_0046: 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_0065: Expected O, but got Unknown
			//IL_0065: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_009e: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00d7: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_010c: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_0141: Expected O, but got Unknown
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Expected O, but got Unknown
			//IL_0176: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Expected O, but got Unknown
			//IL_01ab: Expected O, but got Unknown
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Expected O, but got Unknown
			//IL_01e4: Expected O, but got Unknown
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Expected O, but got Unknown
			//IL_0219: Expected O, but got Unknown
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Expected O, but got Unknown
			//IL_024e: Expected O, but got Unknown
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Expected O, but got Unknown
			//IL_0287: Expected O, but got Unknown
			AIBlacklist.useVanillaAIBlacklist = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("Settings", "Item Blacklist - Use Vanilla Blacklist"), true, new ConfigDescription("Automatically blacklist items that are blacklisted in vanilla.", (AcceptableValueBase)null, Array.Empty<object>())).Value;
			AIBlacklist.itemBlacklistString = ((BaseUnityPlugin)this).Config.Bind<string>(new ConfigDefinition("Settings", "Item Blacklist"), "Icicle, PrimarySkillShuriken, ImmuneToDebuff, ShockNearby, NovaOnHeal, Thorns, DroneWeapons, FreeChest, RegeneratingScrap", new ConfigDescription("List item codenames separated by commas (ex. Behemoth, ShockNearby, Clover). List of item codenames can be found by using the list_item console command from the DebugToolKit mod.", (AcceptableValueBase)null, Array.Empty<object>())).Value;
			AIEquipBlacklist.equipmentBlacklistString = ((BaseUnityPlugin)this).Config.Bind<string>(new ConfigDefinition("Settings", "Equipment Blacklist"), "MultiShopCard, BossHunter, BossHunterConsumed, VendingMachine, LeaveStage, CLASSICITEMSRETURNS_EQUIPMENT_CREATEGHOSTTARGETING, CLASSICITEMSRETURNS_EQUIPMENT_LOSTDOLL, CursedScythe", new ConfigDescription("List equipment codenames separated by commas. List of item codenames can be found by using the list_item console command from the DebugToolKit mod.", (AcceptableValueBase)null, Array.Empty<object>())).Value;
			VengeanceBlacklist.vengeanceItemBlacklistString = ((BaseUnityPlugin)this).Config.Bind<string>(new ConfigDefinition("Vengeance Settings", "Vengeance Item Blacklist"), "ShockNearby, NovaOnHeal, Thorns", new ConfigDescription("Item Blacklist for Vengeance Clones. Same format as the global AI item blacklist.", (AcceptableValueBase)null, Array.Empty<object>())).Value;
			VengeanceBlacklist.fixVengeanceScaling = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("Vengeance Settings", "Fix Scaling"), true, new ConfigDescription("Fix Vengeance clones always being level 1.", (AcceptableValueBase)null, Array.Empty<object>())).Value;
			VengeanceBlacklist.useAIBlacklist = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("Vengeance Settings", "Use AI Blacklist"), true, new ConfigDescription("Automatically remove items with the AIBlacklist tag.", (AcceptableValueBase)null, Array.Empty<object>())).Value;
			VengeanceBlacklist.useTurretBlacklist = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("Vengeance Settings", "Use Engi Turret Blacklist"), true, new ConfigDescription("Automatically remove items with the CannotCopy tag.", (AcceptableValueBase)null, Array.Empty<object>())).Value;
			MithrixBlacklist.useVanillaMithrixBlacklist = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("Mithrix Settings", "Use Vanilla Blacklist"), true, new ConfigDescription("Automatically blacklist items that are blacklisted in vanilla.", (AcceptableValueBase)null, Array.Empty<object>())).Value;
			MithrixBlacklist.mithrixBlacklistString = ((BaseUnityPlugin)this).Config.Bind<string>(new ConfigDefinition("Mithrix Settings", "Mithrix Blacklist"), "ShockNearby, NovaOnHeal, Thorns", new ConfigDescription("List item codenames separated by commas (ex. Behemoth, ShockNearby, Clover). To specify an item cap instead, enter a - followed by the max cap (ex. Behemoth - 5, ShockNearby, Clover - 1). List of item codenames can be found by using the list_item console command from the DebugToolKit mod.", (AcceptableValueBase)null, Array.Empty<object>())).Value;
			MithrixBlacklist.blacklistAllItems = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("Mithrix Settings", "Blacklist All Items (EXPERIMENTAL)"), false, new ConfigDescription("Blacklist EVERY item from Mithrix. MAY CAUSE UNEXPECTED BEHAVIOR.", (AcceptableValueBase)null, Array.Empty<object>())).Value;
			ScavengerBlacklist.useScavBlacklist = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("Scavenger Settings", "Use Separate Scavenger Blacklist"), false, new ConfigDescription("Scavengers get a separate blacklist from the generic AI Blacklist. Enabling this might break compatibility with mods that modify Scavengers.", (AcceptableValueBase)null, Array.Empty<object>())).Value;
			ScavengerBlacklist.scavBlacklistString = ((BaseUnityPlugin)this).Config.Bind<string>(new ConfigDefinition("Scavenger Settings", "Scavenger Blacklist"), "PrimarySkillShuriken, ImmuneToDebuff, DroneWeapons, FreeChest, RegeneratingScrap, SprintBonus, SprintArmor, MushroomVoid, BossDamageBonus, Dagger, ExecuteLowHealthElite, FallBoots, Feather, Firework, FocusConvergence, GoldOnHurt, HeadHunter, HealingPotion, KillEliteFrenzy, LunarPrimaryReplacement, LunarSecondaryReplacement, LunarSpecialReplacement, LunarUtilityReplacement, MonstersOnShrineUse, Mushroom, Squid, StunChanceOnHit, TPHealingNova, Thorns, TreasureCache, TreasureCacheVoid, WardOnLevel, ShockNearby, NovaOnHeal", new ConfigDescription("List item codenames separated by commas (ex. Behemoth, ShockNearby, Clover). List of item codenames can be found by using the list_item console command from the DebugToolKit mod. Vanilla AI Blacklist is included by default.", (AcceptableValueBase)null, Array.Empty<object>())).Value;
		}

		public void Awake()
		{
			ReadConfig();
			new AIBlacklist();
			new VengeanceBlacklist();
			new AIEquipBlacklist();
			new MithrixBlacklist();
			new ScavengerBlacklist();
		}
	}
}