Decompiled source of Enchantments Balancer Pack v0.0.2

OutwardEnchantmentsBalancerPack.dll

Decompiled 3 weeks ago
  Download (90.2 KB) 
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using OutwardEnchantmentsBalancerPack.Events;
using OutwardEnchantmentsBalancerPack.Managers;
using OutwardEnchantmentsBalancerPack.Utility.Data;
using OutwardEnchantmentsBalancerPack.Utility.Enums;
using OutwardEnchantmentsBalancerPack.Utility.Helpers;
using OutwardEnchantmentsBalancerPack.Utility.Helpers.Factories;
using OutwardModsCommunicator;
using OutwardModsCommunicator.EventBus;
using SideLoader;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("OutwardModPackTemplate")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OutwardModPackTemplate")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c5450fe0-edcf-483f-b9ea-4b1ef9d36da7")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace OutwardEnchantmentsBalancerPack
{
	[BepInPlugin("gymmed.enchantments_balancer_pack", "Enchantments Balancer Pack", "0.0.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class OEBP : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(ResourcesPrefabManager), "Load")]
		public class ResourcesPrefabManager_Load
		{
			private static void Postfix(ResourcesPrefabManager __instance)
			{
				PublishLoot();
				ItemsPriceManager.Instance.BalancePrices();
			}
		}

		public const string GUID = "gymmed.enchantments_balancer_pack";

		public const string NAME = "Enchantments Balancer Pack";

		public const string VERSION = "0.0.2";

		public static string prefix = "[Enchantments-Balancer]";

		public const string LOOT_MANAGER_GUID = "gymmed.loot_manager";

		public static string LOOT_MANAGER_ALL_GUID = "gymmed.loot_manager_*";

		internal static ManualLogSource Log;

		internal void Awake()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			LogMessage("Hello world from Enchantments Balancer Pack 0.0.2!");
			OMC.xmlFilePath = Path.Combine(GetProjectLocation(), "MyModsOverrides.xml");
			new Harmony("gymmed.enchantments_balancer_pack").PatchAll();
			EventBus.Subscribe("gymmed.enchantments_balancer_pack_*", "OEBP@OverwriteXmlFilePath", (Action<EventPayload>)OverwriteXmlFilePath);
		}

		private void OverwriteXmlFilePath(EventPayload payload)
		{
			if (payload != null)
			{
				string text = payload.Get<string>("xmlFilePath", (string)null);
				if (string.IsNullOrEmpty(text))
				{
					LogSL("OEBP@OverwriteXmlFilePath string variable xmlFilePath is missing! Make sure to provide xmlFilePath.");
				}
				LogSL("xmlFilePath = " + text);
			}
		}

		internal void Update()
		{
		}

		public static void LogMessage(string message)
		{
			Log.LogMessage((object)(prefix + " " + message));
		}

		public static void LogSL(string message)
		{
			SL.Log(prefix + " " + message);
		}

		public static string GetProjectLocation()
		{
			return Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
		}

		public static void PublishLoot()
		{
			try
			{
				List<ItemDropChance> allEnchantmentItemsAsDropChances = EnchantmentRecipeItemManager.Instance.GetAllEnchantmentItemsAsDropChances();
				EventBusPublisher.PublishRootDrops(allEnchantmentItemsAsDropChances);
				EventBusPublisher.PublishFireDrops(allEnchantmentItemsAsDropChances);
				EventBusPublisher.PublishIceDrops(allEnchantmentItemsAsDropChances);
				EventBusPublisher.PublishHorrorDrops(allEnchantmentItemsAsDropChances);
				EventBusPublisher.PublishGiantDrops(allEnchantmentItemsAsDropChances);
				EventBusPublisher.PublishBanditsDrops(allEnchantmentItemsAsDropChances);
				EventBusPublisher.PublishUniquesDrops(allEnchantmentItemsAsDropChances);
				EventBusPublisher.PublishIceWitchDrops(allEnchantmentItemsAsDropChances);
				EventBusPublisher.PublishAncientDwellerDrops(allEnchantmentItemsAsDropChances);
				EventBusPublisher.PublishGlobalDrops();
			}
			catch (Exception ex)
			{
				LogMessage("OutwardEnchantmentsBalancerPack@PublishLoot we encountered an errpr: \"" + ex.Message + "\"");
			}
		}
	}
}
namespace OutwardEnchantmentsBalancerPack.Utility.Helpers
{
	public static class EventPayLoadHelpers
	{
		public static void AssignDistributedDataToPayLoad(EventPayload payload, DropChancesDistributedData data)
		{
			payload.Set(LootManagerParamsHelper.Get(LootManagerParams.EmptyDropChance).key, (object)data.EmptyDropChance);
			payload.Set(LootManagerParamsHelper.Get(LootManagerParams.MaxDiceValue).key, (object)data.GetMaxDiceValue());
		}

		public static void AssignDistributedDataToPayLoad(EventPayload payload, DropChancesDistributedData data, List<ItemDropChance> items)
		{
			AssignDistributedDataToPayLoad(payload, data);
			payload.Set(LootManagerParamsHelper.Get(LootManagerParams.ListOfItemDropChances).key, (object)items);
		}

		public static void SetDistributedEnchantmentsToPayload(EventPayload payload, List<ItemDropChance> items, List<ItemDropChance> enchantments, int emptyDropChance = 0)
		{
			List<ItemDropChance> distributionItems = ItemDropChanceHelpers.CopyItemDropChances(enchantments);
			GetAndSetDistributedDataToPayload(payload, items, distributionItems, emptyDropChance);
		}

		public static void GetAndSetDistributedDataToPayload(EventPayload payload, List<ItemDropChance> items, List<ItemDropChance> distributionItems, int emptyDropChance = 0)
		{
			try
			{
				List<ItemDropChance> list = new List<ItemDropChance>();
				DropChancesDistributedData data = ItemDropChanceHelpers.DistributeEquallyItemDropChancesWeights(items, distributionItems, emptyDropChance);
				list.AddRange(items);
				list.AddRange(distributionItems);
				AssignDistributedDataToPayLoad(payload, data, list);
			}
			catch (Exception ex)
			{
				OEBP.LogMessage("OutwardEnchantmentsBalancerPack@PublishLoot we encountered an errpr: \"" + ex.Message + "\"");
			}
		}

		public static void GetAndSetDistributedDataToPayload(EventPayload payload, ItemDropChance item, List<ItemDropChance> enchantments, int emptyDropChance = 0)
		{
			List<ItemDropChance> items = new List<ItemDropChance>(BasicItemDrop.op_Implicit((BasicItemDrop)(object)item));
			GetAndSetDistributedDataToPayload(payload, items, enchantments, emptyDropChance);
		}

		public static void GetAndSetDistributedEnchantmentsDataToPayload(EventPayload payload, ItemDropChance item, List<ItemDropChance> enchantments, int emptyDropChance = 0)
		{
			List<ItemDropChance> items = new List<ItemDropChance>(BasicItemDrop.op_Implicit((BasicItemDrop)(object)item));
			SetDistributedEnchantmentsToPayload(payload, items, enchantments, emptyDropChance);
		}
	}
	public static class ItemDropChanceHelpers
	{
		public static DropChancesDistributedData DistributeEquallyItemDropChancesWeights(List<ItemDropChance> items, int emptyDropChance = 0)
		{
			if (items == null || items.Count == 0)
			{
				return new DropChancesDistributedData();
			}
			emptyDropChance = Mathf.Clamp(emptyDropChance, 0, 100);
			int num = 100 - emptyDropChance;
			int emptyDropChance2 = emptyDropChance * items.Count;
			int dropChance = num;
			foreach (ItemDropChance item in items)
			{
				item.DropChance = dropChance;
			}
			return new DropChancesDistributedData(emptyDropChance2, items.Count);
		}

		public static DropChancesDistributedData DistributeEquallyItemDropChancesWeights(List<ItemDropChance> respectItemsChances, List<ItemDropChance> distributeItemsChances, int emptyDropChance = 0)
		{
			if (respectItemsChances == null)
			{
				respectItemsChances = new List<ItemDropChance>();
			}
			if (distributeItemsChances == null)
			{
				distributeItemsChances = new List<ItemDropChance>();
			}
			if (respectItemsChances.Count == 0 && distributeItemsChances.Count == 0)
			{
				return new DropChancesDistributedData();
			}
			emptyDropChance = Mathf.Clamp(emptyDropChance, 0, 100);
			float num = respectItemsChances.Sum((ItemDropChance i) => Mathf.Max(0, i.DropChance));
			float num2 = Mathf.Max(0f, (float)(100 - emptyDropChance) - num);
			if (num2 < 0f && num > 0f)
			{
				float num3 = (100f - (float)emptyDropChance) / num;
				foreach (ItemDropChance respectItemsChance in respectItemsChances)
				{
					respectItemsChance.DropChance = Mathf.RoundToInt((float)respectItemsChance.DropChance * num3);
				}
				num = respectItemsChances.Sum((ItemDropChance i) => i.DropChance);
				num2 = Mathf.Max(0f, 100f - (float)emptyDropChance - num);
			}
			int num4 = respectItemsChances.Count + distributeItemsChances.Count;
			if (num4 == 0)
			{
				return new DropChancesDistributedData();
			}
			int emptyDropChance2 = Mathf.RoundToInt((float)(emptyDropChance * num4));
			foreach (ItemDropChance respectItemsChance2 in respectItemsChances)
			{
				respectItemsChance2.DropChance *= num4;
			}
			int dropChance = Mathf.RoundToInt(((distributeItemsChances.Count > 0) ? (num2 / (float)distributeItemsChances.Count) : 0f) * (float)num4);
			foreach (ItemDropChance distributeItemsChance in distributeItemsChances)
			{
				distributeItemsChance.DropChance = dropChance;
			}
			return new DropChancesDistributedData(emptyDropChance2, num4);
		}

		public static List<ItemDropChance> CopyItemDropChances(List<ItemDropChance> original)
		{
			if (original == null)
			{
				return new List<ItemDropChance>();
			}
			return original.Select((ItemDropChance i) => CopyItemDropChance(i)).ToList();
		}

		public static ItemDropChance CopyItemDropChance(ItemDropChance original)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			return new ItemDropChance
			{
				ItemID = ((BasicItemDrop)original).ItemID,
				DropChance = original.DropChance,
				MaxDropCount = ((BasicItemDrop)original).MaxDropCount,
				MinDropCount = ((BasicItemDrop)original).MinDropCount,
				MaxDiceRollValue = original.MaxDiceRollValue,
				MinDiceRollValue = original.MinDiceRollValue
			};
		}
	}
	public static class ItemDropHelpers
	{
		public static List<ItemDropChance> GetEnchantmentIngrediantsDrops(int tourmalineChance = 10, int quartzChance = 10, int rootChance = 0)
		{
			List<ItemDropChance> list = new List<ItemDropChance>();
			if (tourmalineChance > 0)
			{
				list.Add(GetTourmalineDrop(tourmalineChance, 1, 1));
			}
			if (quartzChance > 0)
			{
				list.Add(GetPurifyingQuartzDrop(quartzChance, 1, 1));
			}
			if (rootChance > 0)
			{
				list.Add(GetDreamersRootDrop(rootChance, 1, 3));
			}
			return list;
		}

		public static ItemDropChance GetTourmalineDrop(int dropChance = 10, int minDropCount = 1, int maxDropCount = 2, int minDiceRoll = 0, int maxDiceRoll = 0)
		{
			return CreateItemDropChace(6200170, dropChance, minDropCount, maxDropCount, minDiceRoll, maxDiceRoll);
		}

		public static ItemDropChance GetPurifyingQuartzDrop(int dropChance = 10, int minDropCount = 1, int maxDropCount = 2, int minDiceRoll = 0, int maxDiceRoll = 0)
		{
			return CreateItemDropChace(6000170, dropChance, minDropCount, maxDropCount, minDiceRoll, maxDiceRoll);
		}

		public static ItemDropChance GetDreamersRootDrop(int dropChance = 10, int minDropCount = 1, int maxDropCount = 2, int minDiceRoll = 0, int maxDiceRoll = 0)
		{
			return CreateItemDropChace(4000360, dropChance, minDropCount, maxDropCount, minDiceRoll, maxDiceRoll);
		}

		public static ItemDropChance GetSpecificParticleDrop(ElementalParticles particle, int dropChance = 10, int minDropCount = 1, int maxDropCount = 2, int minDiceRoll = 0, int maxDiceRoll = 0)
		{
			return CreateItemDropChace(ElementalParticlesHelper.GetItemID(particle), dropChance, minDropCount, maxDropCount, minDiceRoll, maxDiceRoll);
		}

		public static ItemDropChance CreateItemDropChace(int itemId, int dropChance = 10, int minDropCount = 1, int maxDropCount = 2, int minDiceRoll = 0, int maxDiceRoll = 0)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_0021: 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_0032: Expected O, but got Unknown
			return new ItemDropChance
			{
				DropChance = dropChance,
				ItemID = itemId,
				MinDropCount = minDropCount,
				MaxDropCount = maxDropCount,
				MinDiceRollValue = minDiceRoll,
				MaxDiceRollValue = maxDiceRoll
			};
		}

		public static List<ItemDropChance> GetIncensesDrop(int dropChance = 1, int minDropCount = 1, int maxDropCount = 2)
		{
			List<ItemDropChance> list = new List<ItemDropChance>();
			foreach (KeyValuePair<IncensesTypes, int> incensesId in IncensesTypesHelper.IncensesIds)
			{
				list.Add(CreateItemDropChace(incensesId.Value, dropChance, minDropCount, maxDropCount));
			}
			return list;
		}

		public static List<ItemDropChance> GetGuaranteedParticlesDrop(int minDropCount = 1, int maxDropCount = 2)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			ItemDropChance val = new ItemDropChance();
			val.DropChance = 20;
			((BasicItemDrop)val).ItemID = ElementalParticlesHelper.GetItemID(ElementalParticles.Decay);
			((BasicItemDrop)val).MinDropCount = minDropCount;
			((BasicItemDrop)val).MaxDropCount = maxDropCount;
			val.MinDiceRollValue = 0;
			val.MaxDiceRollValue = 20;
			ItemDropChance val2 = new ItemDropChance();
			val2.DropChance = 20;
			((BasicItemDrop)val2).ItemID = ElementalParticlesHelper.GetItemID(ElementalParticles.Either);
			((BasicItemDrop)val2).MinDropCount = minDropCount;
			((BasicItemDrop)val2).MaxDropCount = maxDropCount;
			val2.MinDiceRollValue = 20;
			val2.MaxDiceRollValue = 40;
			ItemDropChance val3 = new ItemDropChance();
			val3.DropChance = 20;
			((BasicItemDrop)val3).ItemID = ElementalParticlesHelper.GetItemID(ElementalParticles.Fire);
			((BasicItemDrop)val3).MinDropCount = minDropCount;
			((BasicItemDrop)val3).MaxDropCount = maxDropCount;
			val3.MinDiceRollValue = 40;
			val3.MaxDiceRollValue = 60;
			ItemDropChance val4 = new ItemDropChance();
			val4.DropChance = 20;
			((BasicItemDrop)val4).ItemID = ElementalParticlesHelper.GetItemID(ElementalParticles.Ice);
			((BasicItemDrop)val4).MinDropCount = minDropCount;
			((BasicItemDrop)val4).MaxDropCount = maxDropCount;
			val4.MinDiceRollValue = 60;
			val4.MaxDiceRollValue = 80;
			ItemDropChance val5 = new ItemDropChance();
			val5.DropChance = 20;
			((BasicItemDrop)val5).ItemID = ElementalParticlesHelper.GetItemID(ElementalParticles.Light);
			((BasicItemDrop)val5).MinDropCount = minDropCount;
			((BasicItemDrop)val5).MaxDropCount = maxDropCount;
			val5.MinDiceRollValue = 80;
			val5.MaxDiceRollValue = 100;
			return new List<ItemDropChance> { val, val2, val3, val4, val5 };
		}
	}
	public static class MerchantHelpers
	{
		public static bool TryMoveItemsToContainer(ItemContainer container, List<Item> items)
		{
			float num = 0f;
			foreach (Item item in items)
			{
				num += item.Weight;
			}
			return container.TryMoveItemsToContainer((IList<Item>)items, num, true);
		}

		public static void AddContainedContainerItems(ItemContainer container, List<Item> items)
		{
			string text = "";
			foreach (Item item in items)
			{
				text = item.UID.ToString();
				if (!container.m_containedItems.ContainsKey(text))
				{
					container.m_containedItems.Add(text, item);
				}
			}
			AddItemsToContainer(container, items);
		}

		public static void AddItemsToContainer(ItemContainer container, List<Item> items)
		{
			foreach (Item item in items)
			{
				container.AddItem(item);
			}
		}

		public static List<int> GetRandomIncensesIds(int randomAmount = 3)
		{
			List<int> list = IncensesTypesHelper.IncensesIds.Values.ToList();
			int num = 0;
			List<int> list2 = new List<int>();
			for (int i = 0; i < randomAmount; i++)
			{
				num = Random.Range(0, list.Count);
				list2.Add(list[num]);
				list.RemoveAt(num);
			}
			return list2;
		}

		public static List<Item> GenerateItemsByIds(List<int> ids, int minItems = 1, int maxItems = 1)
		{
			List<Item> list = new List<Item>();
			Item val = null;
			int num = 1;
			int num2 = 0;
			foreach (int id in ids)
			{
				num = Random.Range(minItems, maxItems);
				for (num2 = 0; num2 < num; num2++)
				{
					val = ItemManager.Instance.GenerateItemNetwork(id);
					if (!((Object)(object)val == (Object)null))
					{
						list.Add(val);
					}
				}
			}
			return list;
		}
	}
}
namespace OutwardEnchantmentsBalancerPack.Utility.Helpers.Factories
{
	public static class DropFactory
	{
		public static List<ItemDropChance> GetEnchantmentIngrediantsDrops(DropConfig tourmalineConfig = default(DropConfig), DropConfig quartzConfig = default(DropConfig), DropConfig rootConfig = default(DropConfig))
		{
			if (tourmalineConfig.Equals(null))
			{
				tourmalineConfig = default(DropConfig);
			}
			if (quartzConfig.Equals(null))
			{
				quartzConfig = default(DropConfig);
			}
			if (rootConfig.Equals(null))
			{
				rootConfig = new DropConfig(0);
			}
			List<ItemDropChance> list = new List<ItemDropChance>();
			if (tourmalineConfig.DropChance > 0)
			{
				list.Add(GetTourmalineDrop(tourmalineConfig.DropChance, tourmalineConfig.MinCount, tourmalineConfig.MaxCount, tourmalineConfig.MinDice, tourmalineConfig.MaxDice));
			}
			if (quartzConfig.DropChance > 0)
			{
				list.Add(GetPurifyingQuartzDrop(quartzConfig.DropChance, quartzConfig.MinCount, quartzConfig.MaxCount, quartzConfig.MinDice, quartzConfig.MaxDice));
			}
			if (rootConfig.DropChance > 0)
			{
				list.Add(GetDreamersRootDrop(rootConfig.DropChance, rootConfig.MinCount, rootConfig.MaxCount, rootConfig.MinDice, rootConfig.MaxDice));
			}
			return list;
		}

		public static ItemDropChance GetTourmalineDrop(DropConfig config = default(DropConfig))
		{
			if (config.Equals(null))
			{
				config = default(DropConfig);
			}
			return GetTourmalineDrop(config.DropChance, config.MinCount, config.MaxCount, config.MinDice, config.MaxDice);
		}

		public static ItemDropChance GetPurifyingQuartzDrop(DropConfig config = default(DropConfig))
		{
			if (config.Equals(null))
			{
				config = default(DropConfig);
			}
			return GetPurifyingQuartzDrop(config.DropChance, config.MinCount, config.MaxCount, config.MinDice, config.MaxDice);
		}

		public static ItemDropChance GetRootDrop(DropConfig config = default(DropConfig))
		{
			if (config.Equals(null))
			{
				config = default(DropConfig);
			}
			return GetDreamersRootDrop(config.DropChance, config.MinCount, config.MaxCount, config.MinDice, config.MaxDice);
		}

		public static ItemDropChance GetTourmalineDrop(int dropChance = 10, int minDropCount = 1, int maxDropCount = 2, int minDiceRoll = 0, int maxDiceRoll = 0)
		{
			return CreateItemDropChance(6200170, dropChance, minDropCount, maxDropCount, minDiceRoll, maxDiceRoll);
		}

		public static ItemDropChance GetPurifyingQuartzDrop(int dropChance = 10, int minDropCount = 1, int maxDropCount = 2, int minDiceRoll = 0, int maxDiceRoll = 0)
		{
			return CreateItemDropChance(6000170, dropChance, minDropCount, maxDropCount, minDiceRoll, maxDiceRoll);
		}

		public static ItemDropChance GetDreamersRootDrop(int dropChance = 10, int minDropCount = 1, int maxDropCount = 2, int minDiceRoll = 0, int maxDiceRoll = 0)
		{
			return CreateItemDropChance(4000360, dropChance, minDropCount, maxDropCount, minDiceRoll, maxDiceRoll);
		}

		public static List<ItemDropChance> CombineDrops(params ItemDropChance[] drops)
		{
			return new List<ItemDropChance>(drops);
		}

		public static List<ItemDropChance> CombineDrops(params List<ItemDropChance>[] dropLists)
		{
			List<ItemDropChance> list = new List<ItemDropChance>();
			foreach (List<ItemDropChance> collection in dropLists)
			{
				list.AddRange(collection);
			}
			return list;
		}

		private static ItemDropChance CreateItemDropChance(int itemId, int dropChance, int minDropCount, int maxDropCount, int minDiceRoll, int maxDiceRoll)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_0021: 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_0032: Expected O, but got Unknown
			return new ItemDropChance
			{
				ItemID = itemId,
				DropChance = dropChance,
				MinDropCount = minDropCount,
				MaxDropCount = maxDropCount,
				MinDiceRollValue = minDiceRoll,
				MaxDiceRollValue = maxDiceRoll
			};
		}
	}
}
namespace OutwardEnchantmentsBalancerPack.Utility.Enums
{
	public enum ElementalParticles
	{
		Decay = 6000140,
		Either = 6000150,
		Fire = 6000110,
		Ice = 6000120,
		Light = 6000130
	}
	public static class ElementalParticlesHelper
	{
		public static readonly Dictionary<ElementalParticles, int> ParticleItemIDs = new Dictionary<ElementalParticles, int>
		{
			{
				ElementalParticles.Decay,
				6000140
			},
			{
				ElementalParticles.Either,
				6000150
			},
			{
				ElementalParticles.Fire,
				6000110
			},
			{
				ElementalParticles.Ice,
				6000120
			},
			{
				ElementalParticles.Light,
				6000130
			}
		};

		public static int ParticleSellPrice = 18;

		public static int GetItemID(ElementalParticles type)
		{
			if (!ParticleItemIDs.TryGetValue(type, out var value))
			{
				return -1;
			}
			return value;
		}

		public static ElementalParticles? GetParticleType(int itemID)
		{
			foreach (KeyValuePair<ElementalParticles, int> particleItemID in ParticleItemIDs)
			{
				if (particleItemID.Value == itemID)
				{
					return particleItemID.Key;
				}
			}
			return null;
		}
	}
	public enum EnchantmentEssentials
	{
		Table,
		Pillar
	}
	public static class EnchantmentEssiantialsHelper
	{
		public static readonly Dictionary<EnchantmentEssentials, int> essentialsIds = new Dictionary<EnchantmentEssentials, int>
		{
			{
				EnchantmentEssentials.Table,
				5000200
			},
			{
				EnchantmentEssentials.Pillar,
				5000203
			}
		};
	}
	public enum EnchantmentIngrediants
	{
		Tourmaline,
		PurifyingQuartz,
		DreamersRoot
	}
	public static class EnchantmentIngrediantsHelper
	{
		public static readonly Dictionary<EnchantmentIngrediants, int> ItemsIds = new Dictionary<EnchantmentIngrediants, int>
		{
			{
				EnchantmentIngrediants.Tourmaline,
				6200170
			},
			{
				EnchantmentIngrediants.PurifyingQuartz,
				6000170
			},
			{
				EnchantmentIngrediants.DreamersRoot,
				4000360
			}
		};

		public static readonly Dictionary<EnchantmentIngrediants, int> NewSellPrices = new Dictionary<EnchantmentIngrediants, int>
		{
			{
				EnchantmentIngrediants.Tourmaline,
				20
			},
			{
				EnchantmentIngrediants.PurifyingQuartz,
				5
			},
			{
				EnchantmentIngrediants.DreamersRoot,
				1
			}
		};

		public static int GetItemPrice(EnchantmentIngrediants ingrediant)
		{
			if (NewSellPrices.TryGetValue(ingrediant, out var value))
			{
				return value;
			}
			return 0;
		}

		public static int GetItemId(EnchantmentIngrediants ingrediant)
		{
			if (ItemsIds.TryGetValue(ingrediant, out var value))
			{
				return value;
			}
			return 0;
		}
	}
	public enum IncensesTypes
	{
		Monarch,
		Cecropia,
		Admiral,
		Chrysalis,
		PaleBeauty,
		Apollo,
		Comet,
		Luna,
		Morpho,
		Sylphina
	}
	public static class IncensesTypesHelper
	{
		public static readonly Dictionary<IncensesTypes, int> IncensesIds = new Dictionary<IncensesTypes, int>
		{
			{
				IncensesTypes.Monarch,
				6000200
			},
			{
				IncensesTypes.Cecropia,
				6000270
			},
			{
				IncensesTypes.Admiral,
				6000190
			},
			{
				IncensesTypes.Chrysalis,
				6000220
			},
			{
				IncensesTypes.PaleBeauty,
				6000210
			},
			{
				IncensesTypes.Apollo,
				6000180
			},
			{
				IncensesTypes.Comet,
				6000260
			},
			{
				IncensesTypes.Luna,
				6000230
			},
			{
				IncensesTypes.Morpho,
				6000240
			},
			{
				IncensesTypes.Sylphina,
				6000250
			}
		};

		public static int BaseIncesesSellPrice = 25;

		public static int AdvancedIncesesSellPrice = 60;

		public static IncensesTypes[] GetBaseInceses()
		{
			return new IncensesTypes[5]
			{
				IncensesTypes.Monarch,
				IncensesTypes.Cecropia,
				IncensesTypes.Admiral,
				IncensesTypes.Chrysalis,
				IncensesTypes.PaleBeauty
			};
		}

		public static IncensesTypes[] GetAdvancedInceses()
		{
			return new IncensesTypes[5]
			{
				IncensesTypes.Apollo,
				IncensesTypes.Comet,
				IncensesTypes.Luna,
				IncensesTypes.Morpho,
				IncensesTypes.Sylphina
			};
		}

		public static int GetIncenseId(IncensesTypes type)
		{
			if (IncensesIds.TryGetValue(type, out var value))
			{
				return value;
			}
			return 0;
		}
	}
	public enum LootManagerParams
	{
		LootId,
		ItemId,
		DropChance,
		MinDropCount,
		MaxDropCount,
		MinDiceRollValue,
		MaxDiceRollValue,
		EnemyId,
		EnemyName,
		AreaEnum,
		AreaFamily,
		Faction,
		ExceptIds,
		ExceptNames,
		IsForBosses,
		IsForBossesPawns,
		IsForStoryBosses,
		IsForUniqueArenaBosses,
		IsForUniqueEnemies,
		ListOfItemDropChances,
		ItemDropChance,
		MinNumberOfDrops,
		MaxNumberOfDrops,
		EmptyDropChance,
		MaxDiceValue,
		LoadLootsXmlFilePath,
		StoreLootsXmlFilePath
	}
	public static class LootManagerParamsHelper
	{
		private static readonly Dictionary<LootManagerParams, (string key, Type type)> _params = new Dictionary<LootManagerParams, (string, Type)>
		{
			[LootManagerParams.LootId] = ("lootId", typeof(string)),
			[LootManagerParams.ItemId] = ("itemId", typeof(int)),
			[LootManagerParams.DropChance] = ("dropChance", typeof(int)),
			[LootManagerParams.MinDropCount] = ("minDropCount", typeof(int)),
			[LootManagerParams.MaxDropCount] = ("dropChance", typeof(int)),
			[LootManagerParams.MinDiceRollValue] = ("minDiceRollValue", typeof(int)),
			[LootManagerParams.MaxDiceRollValue] = ("maxDiceRollValue", typeof(int)),
			[LootManagerParams.EnemyId] = ("enemyId", typeof(string)),
			[LootManagerParams.EnemyName] = ("enemyName", typeof(string)),
			[LootManagerParams.AreaEnum] = ("area", typeof(AreaEnum?)),
			[LootManagerParams.AreaFamily] = ("areaFamily", typeof(AreaFamily)),
			[LootManagerParams.Faction] = ("faction", typeof(Factions?)),
			[LootManagerParams.ExceptIds] = ("listExceptIds", typeof(List<string>)),
			[LootManagerParams.ExceptNames] = ("listExceptNames", typeof(List<string>)),
			[LootManagerParams.IsForBosses] = ("isForBosses", typeof(bool)),
			[LootManagerParams.IsForBossesPawns] = ("isForBossPawns", typeof(bool)),
			[LootManagerParams.IsForStoryBosses] = ("isForStoryBosses", typeof(bool)),
			[LootManagerParams.IsForUniqueArenaBosses] = ("isForUniqueArenaBosses", typeof(bool)),
			[LootManagerParams.IsForUniqueEnemies] = ("isForUniqueEnemies", typeof(bool)),
			[LootManagerParams.ListOfItemDropChances] = ("listOfItemDropChances", typeof(List<ItemDropChance>)),
			[LootManagerParams.ItemDropChance] = ("itemDropChance", typeof(ItemDropChance)),
			[LootManagerParams.MinNumberOfDrops] = ("minNumberOfDrops", typeof(int)),
			[LootManagerParams.MaxNumberOfDrops] = ("maxNumberOfDrops", typeof(int)),
			[LootManagerParams.EmptyDropChance] = ("emptyDropChance", typeof(int)),
			[LootManagerParams.MaxDiceValue] = ("maxDiceValue", typeof(int)),
			[LootManagerParams.LoadLootsXmlFilePath] = ("filePath", typeof(string)),
			[LootManagerParams.StoreLootsXmlFilePath] = ("filePath", typeof(string))
		};

		public static (string key, Type type) Get(LootManagerParams param)
		{
			return _params[param];
		}
	}
}
namespace OutwardEnchantmentsBalancerPack.Utility.Data
{
	public class DropChancesDistributedData
	{
		private int emptyDropChance;

		private int weightPerPercentage;

		public int WeightPerPercentage
		{
			get
			{
				return weightPerPercentage;
			}
			set
			{
				weightPerPercentage = value;
			}
		}

		public int EmptyDropChance
		{
			get
			{
				return emptyDropChance;
			}
			set
			{
				emptyDropChance = value;
			}
		}

		public DropChancesDistributedData(int emptyDropChance = 0, int weightPerPercentage = 0)
		{
			EmptyDropChance = emptyDropChance;
			WeightPerPercentage = weightPerPercentage;
		}

		public int GetMaxDiceValue()
		{
			return WeightPerPercentage * 100;
		}
	}
	public struct DropConfig
	{
		public int DropChance;

		public int MinCount;

		public int MaxCount;

		public int MinDice;

		public int MaxDice;

		public DropConfig(int dropChance = 10, int minCount = 1, int maxCount = 2, int minDice = 0, int maxDice = 0)
		{
			DropChance = dropChance;
			MinCount = minCount;
			MaxCount = maxCount;
			MinDice = minDice;
			MaxDice = maxDice;
		}
	}
}
namespace OutwardEnchantmentsBalancerPack.Patches
{
	[HarmonyPatch(typeof(MerchantPouch), "RefreshInventory")]
	public class Patch_MerchantPouch_RefreshInventory
	{
		public static readonly Dictionary<string, string> MerchantsToFillIncense = new Dictionary<string, string>
		{
			{ "Fourth Watcher", "9Qi1PDHnIUKf-eNT8Y3FJQ" },
			{ "Agatha, Maiden of the Winds", "YMvgNzX7JEG6PnQdK1Z-Dg" }
		};

		private static void Prefix(MerchantPouch __instance, Dropable _dropable)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (!(EnvironmentConditions.GameTime < __instance.m_nextRefreshTime) && !PhotonNetwork.isNonMasterClientInRoom && !((Object)(object)__instance.Merchant == (Object)null))
			{
				if (UnityEngineExtensions.Contains(__instance.Merchant.ShopName, "Alchemist", StringComparison.OrdinalIgnoreCase))
				{
					int randomAmount = Random.Range(1, 6);
					MerchantHelpers.TryMoveItemsToContainer((ItemContainer)(object)__instance, MerchantHelpers.GenerateItemsByIds(MerchantHelpers.GetRandomIncensesIds(randomAmount), 1, 5));
				}
				Dictionary<string, string>.ValueCollection values = MerchantsToFillIncense.Values;
				UID holderUID = __instance.Merchant.HolderUID;
				if (values.Contains(((UID)(ref holderUID)).Value))
				{
					int randomAmount2 = Random.Range(1, 6);
					MerchantHelpers.TryMoveItemsToContainer((ItemContainer)(object)__instance, MerchantHelpers.GenerateItemsByIds(MerchantHelpers.GetRandomIncensesIds(randomAmount2), 1, 5));
				}
			}
		}
	}
}
namespace OutwardEnchantmentsBalancerPack.Managers
{
	public class EnchantmentRecipeItemManager
	{
		private static EnchantmentRecipeItemManager _instance;

		private Dictionary<int, int> enchantmentToEnchantmentRecipeItems = new Dictionary<int, int>();

		public static EnchantmentRecipeItemManager Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new EnchantmentRecipeItemManager();
				}
				return _instance;
			}
		}

		public Dictionary<int, int> EnchantmentToEnchantmentRecipeItems
		{
			get
			{
				return enchantmentToEnchantmentRecipeItems;
			}
			set
			{
				enchantmentToEnchantmentRecipeItems = value;
			}
		}

		private EnchantmentRecipeItemManager()
		{
			MakeEnchantmentDictionary();
		}

		public void MakeEnchantmentDictionary()
		{
			EnchantmentToEnchantmentRecipeItems.Clear();
			foreach (KeyValuePair<string, Item> iTEM_PREFAB in ResourcesPrefabManager.ITEM_PREFABS)
			{
				Item value = iTEM_PREFAB.Value;
				EnchantmentRecipeItem val = (EnchantmentRecipeItem)(object)((value is EnchantmentRecipeItem) ? value : null);
				if (val != null && val.Recipes.Length >= 1)
				{
					Enchantment enchantmentPrefab = ResourcesPrefabManager.Instance.GetEnchantmentPrefab(val.Recipes[0].RecipeID);
					if (!((Object)(object)enchantmentPrefab == (Object)null) && !EnchantmentToEnchantmentRecipeItems.TryGetValue(((EffectPreset)enchantmentPrefab).PresetID, out var _))
					{
						EnchantmentToEnchantmentRecipeItems.Add(((EffectPreset)enchantmentPrefab).PresetID, ((Item)val).ItemID);
					}
				}
			}
		}

		public List<EnchantmentRecipeItem> GetAllEnchantmentItems()
		{
			List<EnchantmentRecipeItem> list = new List<EnchantmentRecipeItem>();
			foreach (KeyValuePair<int, int> enchantmentToEnchantmentRecipeItem in EnchantmentToEnchantmentRecipeItems)
			{
				list.Add(GetEnchantmentRecipeItemFromEnchantment(enchantmentToEnchantmentRecipeItem.Key));
			}
			return list;
		}

		public List<ItemDropChance> GetAllEnchantmentItemsAsDropChances()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			foreach (KeyValuePair<int, int> enchantmentToEnchantmentRecipeItem in EnchantmentToEnchantmentRecipeItems)
			{
				ItemDropChance val = new ItemDropChance();
				((BasicItemDrop)val).ItemID = enchantmentToEnchantmentRecipeItem.Value;
				list.Add(val);
			}
			return list;
		}

		public Enchantment GetEnchantmentFromEnchantmentRecipeItem(EnchantmentRecipeItem item)
		{
			if ((Object)(object)item == (Object)null || item.Recipes.Length < 1)
			{
				return null;
			}
			return ResourcesPrefabManager.Instance.GetEnchantmentPrefab(item.Recipes[0].ResultID);
		}

		public Enchantment GetEnchantmentFromEnchantmentRecipeItem(int itemId)
		{
			Item itemPrefab = ResourcesPrefabManager.Instance.GetItemPrefab(itemId);
			EnchantmentRecipeItem item = (EnchantmentRecipeItem)(object)((itemPrefab is EnchantmentRecipeItem) ? itemPrefab : null);
			return GetEnchantmentFromEnchantmentRecipeItem(item);
		}

		public EnchantmentRecipeItem GetEnchantmentRecipeItemFromEnchantment(Enchantment enchantment)
		{
			return GetEnchantmentRecipeItemFromEnchantment(((EffectPreset)enchantment).PresetID);
		}

		public EnchantmentRecipeItem GetEnchantmentRecipeItemFromEnchantment(int enchantmentId)
		{
			Enchantment enchantmentPrefab = ResourcesPrefabManager.Instance.GetEnchantmentPrefab(enchantmentId);
			if ((Object)(object)enchantmentPrefab == (Object)null)
			{
				return null;
			}
			if (!EnchantmentToEnchantmentRecipeItems.TryGetValue(((EffectPreset)enchantmentPrefab).PresetID, out var value))
			{
				return null;
			}
			Item itemPrefab = ResourcesPrefabManager.Instance.GetItemPrefab(value);
			return (EnchantmentRecipeItem)(object)((itemPrefab is EnchantmentRecipeItem) ? itemPrefab : null);
		}
	}
	public class ItemsPriceManager
	{
		private static ItemsPriceManager _instance;

		public static ItemsPriceManager Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new ItemsPriceManager();
				}
				return _instance;
			}
		}

		private ItemsPriceManager()
		{
		}

		public void BalancePrices()
		{
			foreach (KeyValuePair<ElementalParticles, int> particleItemID in ElementalParticlesHelper.ParticleItemIDs)
			{
				AssignNewItemSellValue(particleItemID.Value, ElementalParticlesHelper.ParticleSellPrice);
			}
			foreach (KeyValuePair<EnchantmentIngrediants, int> newSellPrice in EnchantmentIngrediantsHelper.NewSellPrices)
			{
				AssignNewItemSellValue(EnchantmentIngrediantsHelper.GetItemId(newSellPrice.Key), newSellPrice.Value);
			}
			IncensesTypes[] baseInceses = IncensesTypesHelper.GetBaseInceses();
			foreach (IncensesTypes type in baseInceses)
			{
				AssignNewItemSellValue(IncensesTypesHelper.GetIncenseId(type), IncensesTypesHelper.BaseIncesesSellPrice);
			}
			baseInceses = IncensesTypesHelper.GetAdvancedInceses();
			foreach (IncensesTypes type2 in baseInceses)
			{
				AssignNewItemSellValue(IncensesTypesHelper.GetIncenseId(type2), IncensesTypesHelper.AdvancedIncesesSellPrice);
			}
			foreach (EnchantmentRecipeItem allEnchantmentItem in EnchantmentRecipeItemManager.Instance.GetAllEnchantmentItems())
			{
				AssignNewItemSellValue(((Item)allEnchantmentItem).ItemID, ((Item)allEnchantmentItem).Stats.m_baseValue / 3);
			}
		}

		public void AssignNewItemSellValue(int itemId, int sellPrice)
		{
			Item itemPrefab = ResourcesPrefabManager.Instance.GetItemPrefab(itemId);
			if (!((Object)(object)itemPrefab == (Object)null))
			{
				if ((Object)(object)itemPrefab.Stats == (Object)null)
				{
					itemPrefab.m_buyValue_DEPRECATED = sellPrice;
				}
				else
				{
					itemPrefab.Stats.m_baseValue = sellPrice;
				}
			}
		}
	}
	public class SeasonsManager
	{
		private static SeasonsManager _instance;

		public static SeasonsManager Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new SeasonsManager();
				}
				return _instance;
			}
		}

		private SeasonsManager()
		{
		}

		public void Init()
		{
			SL.OnSceneLoaded += delegate
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: 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)
				foreach (Season season in EnvironmentConditions.Instance.Seasons)
				{
					OEBP.LogMessage("name " + ((Object)season).name + " day " + $" minT: {season.MinDayTemperature} maxT:{season.MaxDayTemperature}" + $"night minT: {season.MinNightTemperature} maxT: {season.MaxNightTemperature}");
				}
			};
		}
	}
}
namespace OutwardEnchantmentsBalancerPack.Events
{
	public static class EventBusPublisher
	{
		public static void PublishGolemsDrops(List<ItemDropChance> enchantments)
		{
			PublishForgeGolemDrops(enchantments);
			PublishMoltenForgeGolemDrops(enchantments);
			PublishSwordGolemDrops(enchantments);
			PublishBeastGolemDrops(enchantments);
		}

		public static void PublishMoltenForgeGolemDrops(List<ItemDropChance> enchantments)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_005b: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(5, 1, 1), new DropConfig(5, 1, 1), new DropConfig(10, 1, 3));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Fire, 10, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Forge Golem";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 65);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishForgeGolemDrops(List<ItemDropChance> enchantments)
		{
			//IL_003c: 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_0059: Expected O, but got Unknown
			//IL_005a: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(5, 1, 1), new DropConfig(5, 1, 1), new DropConfig(10, 1, 3));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Light, 5, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Forge Golem";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 70);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishBeastGolemDrops(List<ItemDropChance> enchantments)
		{
			//IL_003c: 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_0059: Expected O, but got Unknown
			//IL_005a: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(5, 1, 1), new DropConfig(5, 1, 1), new DropConfig(10, 1, 3));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Light, 5, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Beast Golem";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 70);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishSwordGolemDrops(List<ItemDropChance> enchantments)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_005b: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(5, 1, 1), new DropConfig(10, 1, 1), new DropConfig(20, 1, 4));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Light, 5, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Sword Golem";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 50);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishTroglodytesDrops(List<ItemDropChance> enchantments)
		{
			PublishTroglodyteDrops();
			PublishManaTroglodyteDrops(enchantments);
			PublishArmoredTroglodyteDrops(enchantments);
			PublishTroglodyteKnightDrops(enchantments);
			PublishTroglodyteGrenadierDrops(enchantments);
		}

		public static void PublishTroglodyteDrops()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_003f: Expected O, but got Unknown
			ItemDropChance dreamersRootDrop = ItemDropHelpers.GetDreamersRootDrop();
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Troglodyte";
			string item2 = LootManagerParamsHelper.Get(LootManagerParams.ItemDropChance).key;
			((Dictionary<string, object>)val)[item2] = dreamersRootDrop;
			EventPayload val2 = val;
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishManaTroglodyteDrops(List<ItemDropChance> enchantments)
		{
			//IL_002c: 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_004b: Expected O, but got Unknown
			//IL_004c: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			ItemDropChance dreamersRootDrop = ItemDropHelpers.GetDreamersRootDrop();
			ItemDropChance purifyingQuartzDrop = ItemDropHelpers.GetPurifyingQuartzDrop();
			list.Add(dreamersRootDrop);
			list.Add(purifyingQuartzDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Mana Troglodyte";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 75);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishArmoredTroglodyteDrops(List<ItemDropChance> enchantments)
		{
			//IL_002c: 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_004b: Expected O, but got Unknown
			//IL_004c: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			ItemDropChance dreamersRootDrop = ItemDropHelpers.GetDreamersRootDrop();
			ItemDropChance purifyingQuartzDrop = ItemDropHelpers.GetPurifyingQuartzDrop();
			list.Add(dreamersRootDrop);
			list.Add(purifyingQuartzDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Armored Troglodyte";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 75);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishTroglodyteKnightDrops(List<ItemDropChance> enchantments)
		{
			//IL_002c: 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_004b: Expected O, but got Unknown
			//IL_004c: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			ItemDropChance dreamersRootDrop = ItemDropHelpers.GetDreamersRootDrop();
			ItemDropChance purifyingQuartzDrop = ItemDropHelpers.GetPurifyingQuartzDrop();
			list.Add(dreamersRootDrop);
			list.Add(purifyingQuartzDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Troglodyte Knight";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 75);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishTroglodyteGrenadierDrops(List<ItemDropChance> enchantments)
		{
			//IL_0047: 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_0066: Expected O, but got Unknown
			//IL_0068: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			ItemDropChance dreamersRootDrop = ItemDropHelpers.GetDreamersRootDrop(10, 1, 2, 0, 10);
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Decay, 10, 1, 1, 10, 15);
			ItemDropChance purifyingQuartzDrop = ItemDropHelpers.GetPurifyingQuartzDrop();
			list.Add(dreamersRootDrop);
			list.Add(specificParticleDrop);
			list.Add(purifyingQuartzDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Troglodyte Grenadier";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 65);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishRootDrops(List<ItemDropChance> enchantments)
		{
			PublishHeynaDrops(enchantments);
			PublishArmoredHeynaDrops(enchantments);
			PublishWalkingHiveDrops(enchantments);
			PublishAssasinBugDrops(enchantments);
			PublishManaMantisDrops(enchantments);
			PublishManticoreDrops(enchantments);
			PublishDeerDrops(enchantments);
			PublishTuanosaursDrops(enchantments);
			PublishGoldenDrops(enchantments);
		}

		public static void PublishGoldenDrops(List<ItemDropChance> enchantments)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_005d: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(5, 1, 1), new DropConfig(5, 1, 1));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Light, 20, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = (object)(Factions)8;
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 65);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishTuanosaursDrops(List<ItemDropChance> enchantments)
		{
			//IL_0036: 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_0055: Expected O, but got Unknown
			//IL_0056: Expected O, but got Unknown
			DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(1, 1, 1), new DropConfig(1, 1, 1), new DropConfig(10, 1, 1));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Decay, 10, 1, 1);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = (object)(Factions)4;
			EventPayload val2 = val;
			EventPayLoadHelpers.GetAndSetDistributedEnchantmentsDataToPayload(val2, specificParticleDrop, enchantments, 68);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishDeerDrops(List<ItemDropChance> enchantments)
		{
			//IL_000c: 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_002b: Expected O, but got Unknown
			//IL_002c: Expected O, but got Unknown
			ItemDropChance dreamersRootDrop = ItemDropHelpers.GetDreamersRootDrop(30, 1, 3);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = (object)(Factions)5;
			EventPayload val2 = val;
			EventPayLoadHelpers.GetAndSetDistributedEnchantmentsDataToPayload(val2, dreamersRootDrop, enchantments, 65);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishHeynaDrops(List<ItemDropChance> enchantments)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_002a: Expected O, but got Unknown
			ItemDropChance dreamersRootDrop = ItemDropHelpers.GetDreamersRootDrop(20, 1, 3);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Hyena";
			EventPayload val2 = val;
			EventPayLoadHelpers.GetAndSetDistributedEnchantmentsDataToPayload(val2, dreamersRootDrop, enchantments, 75);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishJewelbirdDrops(List<ItemDropChance> enchantments)
		{
			//IL_0025: 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_0042: Expected O, but got Unknown
			//IL_0043: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(5, 1, 1), new DropConfig(5, 1, 1), new DropConfig(20, 1, 3));
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Jewelbird";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 60);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishPearlbirdDrops(List<ItemDropChance> enchantments)
		{
			//IL_0025: 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_0042: Expected O, but got Unknown
			//IL_0043: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(0), new DropConfig(5, 1, 1), new DropConfig(20, 1, 3));
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Pearlbird";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 70);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishWalkingHiveDrops(List<ItemDropChance> enchantments)
		{
			//IL_0025: 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_0042: Expected O, but got Unknown
			//IL_0043: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(5, 1, 1), new DropConfig(5, 1, 1), new DropConfig(40, 2, 4));
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Walking Hive";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 30);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishGiantDrops(List<ItemDropChance> enchantments)
		{
			PublishAshGiantDrops(enchantments);
			PublishAshGiantPriestDrops(enchantments);
		}

		public static void PublishAshGiantPriestDrops(List<ItemDropChance> enchantments)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_005b: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(3, 1, 1), new DropConfig(10, 1, 1), new DropConfig(10, 1, 3));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Light, 5, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Ash Giant Priest";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 67);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishManticoreDrops(List<ItemDropChance> enchantments)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_0090: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(10, 1, 1), new DropConfig(10, 1, 1), new DropConfig(20, 1, 3));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Decay, 20, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			ItemDropChance specificParticleDrop2 = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Fire, 10, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop2);
			ItemDropChance specificParticleDrop3 = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Light, 20, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop3);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Manticore";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishManaMantisDrops(List<ItemDropChance> enchantments)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_005b: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(5, 1, 1), new DropConfig(20, 1, 1), new DropConfig(20, 1, 3));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Ice, 5, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Mana Mantis";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 45);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishHiveLordDrops(List<ItemDropChance> enchantments)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_005b: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(5, 1, 1), new DropConfig(2, 1, 1), new DropConfig(10, 1, 3));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Decay, 20, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Hive Lord";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 53);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishBladeDancerDrops(List<ItemDropChance> enchantments)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_005c: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(10, 1, 1), new DropConfig(2, 1, 1), new DropConfig(10, 1, 3));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Decay, 10, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Blade Dancer";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 58);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishAshGiantDrops(List<ItemDropChance> enchantments)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_005b: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(3, 1, 1), new DropConfig(10, 1, 1), new DropConfig(10, 1, 3));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Decay, 5, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Ash Giant";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 67);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishArmoredHeynaDrops(List<ItemDropChance> enchantments)
		{
			//IL_0025: 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_0042: Expected O, but got Unknown
			//IL_0043: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(2, 1, 1), new DropConfig(2, 1, 1), new DropConfig(20, 2, 4));
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Armored Heyna";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 73);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishAssasinBugDrops(List<ItemDropChance> enchantments)
		{
			//IL_0025: 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_0042: Expected O, but got Unknown
			//IL_0043: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(5, 1, 1), new DropConfig(5, 1, 1), new DropConfig(30, 2, 4));
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Assasin Bug";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 50);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishIceDrops(List<ItemDropChance> enchantments)
		{
			PublishCrescentSharkDrops(enchantments);
			PublishWendigoDrops(enchantments);
		}

		public static void PublishFireDrops(List<ItemDropChance> enchantments)
		{
			PublishBurningManDrops(enchantments);
			PublishObsidianElementalDrops(enchantments);
			PublishFireBeetleDrops(enchantments);
		}

		public static void PublishFireBeetleDrops(List<ItemDropChance> enchantments)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_005b: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(2, 1, 1), new DropConfig(2, 1, 1), new DropConfig(20, 1, 3));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Fire, 10, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Fire Beetle";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 61);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishBurningManDrops(List<ItemDropChance> enchantments)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0063: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Fire, 15, 1, 1);
			ItemDropChance purifyingQuartzDrop = ItemDropHelpers.GetPurifyingQuartzDrop(5, 1, 1);
			ItemDropChance tourmalineDrop = ItemDropHelpers.GetTourmalineDrop(5, 1, 1);
			list.Add(specificParticleDrop);
			list.Add(purifyingQuartzDrop);
			list.Add(tourmalineDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Burning Man";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 70);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishObsidianElementalDrops(List<ItemDropChance> enchantments)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0063: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Fire, 20, 1, 1);
			ItemDropChance purifyingQuartzDrop = ItemDropHelpers.GetPurifyingQuartzDrop(5, 1, 1);
			ItemDropChance tourmalineDrop = ItemDropHelpers.GetTourmalineDrop(5, 1, 1);
			list.Add(specificParticleDrop);
			list.Add(purifyingQuartzDrop);
			list.Add(tourmalineDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Obsidian Elemental";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 65);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishHorrorDrops(List<ItemDropChance> enchantments)
		{
			PublishIlluminatorDrops(enchantments);
			PublishIlluminatorHorrorDrops(enchantments);
			PublishShellDrops(enchantments);
			PublishImmaculateDrops(enchantments);
			PublishImmaculateRaiderDrops(enchantments);
			PublishImmaculateWarlockDrops(enchantments);
			PublishBladeDancerDrops(enchantments);
			PublishHiveLordDrops(enchantments);
		}

		public static void PublishShellDrops(List<ItemDropChance> enchantments)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0050: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Decay, 30, 1, 1);
			ItemDropChance purifyingQuartzDrop = ItemDropHelpers.GetPurifyingQuartzDrop(5, 1, 1);
			list.Add(specificParticleDrop);
			list.Add(purifyingQuartzDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Shell Horror";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 60);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishImmaculateWarlockDrops(List<ItemDropChance> enchantments)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0063: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Decay, 15, 1, 1);
			ItemDropChance purifyingQuartzDrop = ItemDropHelpers.GetPurifyingQuartzDrop(5, 1, 1);
			ItemDropChance tourmalineDrop = ItemDropHelpers.GetTourmalineDrop(5, 1, 1);
			list.Add(specificParticleDrop);
			list.Add(purifyingQuartzDrop);
			list.Add(tourmalineDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Immaculate Warlock";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 65);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishImmaculateRaiderDrops(List<ItemDropChance> enchantments)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0063: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Decay, 15, 1, 1);
			ItemDropChance purifyingQuartzDrop = ItemDropHelpers.GetPurifyingQuartzDrop(5, 1, 1);
			ItemDropChance tourmalineDrop = ItemDropHelpers.GetTourmalineDrop(5, 1, 1);
			list.Add(specificParticleDrop);
			list.Add(purifyingQuartzDrop);
			list.Add(tourmalineDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Immaculate Raider";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 65);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishImmaculateDrops(List<ItemDropChance> enchantments)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0063: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Decay, 15, 1, 1);
			ItemDropChance purifyingQuartzDrop = ItemDropHelpers.GetPurifyingQuartzDrop(5, 1, 1);
			ItemDropChance tourmalineDrop = ItemDropHelpers.GetTourmalineDrop(5, 1, 1);
			list.Add(specificParticleDrop);
			list.Add(purifyingQuartzDrop);
			list.Add(tourmalineDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Immaculate";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 65);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishIlluminatorDrops(List<ItemDropChance> enchantments)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0063: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Decay, 15, 1, 1);
			ItemDropChance purifyingQuartzDrop = ItemDropHelpers.GetPurifyingQuartzDrop(5, 1, 1);
			ItemDropChance tourmalineDrop = ItemDropHelpers.GetTourmalineDrop(5, 1, 1);
			list.Add(specificParticleDrop);
			list.Add(purifyingQuartzDrop);
			list.Add(tourmalineDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Illuminator";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 65);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishIlluminatorHorrorDrops(List<ItemDropChance> enchantments)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0063: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Decay, 10, 1, 1);
			ItemDropChance purifyingQuartzDrop = ItemDropHelpers.GetPurifyingQuartzDrop(5, 1, 1);
			ItemDropChance tourmalineDrop = ItemDropHelpers.GetTourmalineDrop(5, 1, 1);
			list.Add(specificParticleDrop);
			list.Add(purifyingQuartzDrop);
			list.Add(tourmalineDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Illuminator Horror";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 70);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishBanditsDrops(List<ItemDropChance> enchantments)
		{
			//IL_0025: 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_0044: Expected O, but got Unknown
			//IL_0045: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(3, 1, 1), new DropConfig(5, 1, 1), new DropConfig(10, 1, 3));
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = (object)(Factions)2;
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 72);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishTestBanditsDrops()
		{
			//IL_0025: 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_003f: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_005c: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(45, 1, 3), new DropConfig(46, 1, 3));
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = enchantmentIngrediantsDrops;
			string item2 = LootManagerParamsHelper.Get(LootManagerParams.Faction).key;
			((Dictionary<string, object>)val)[item2] = (object)(Factions)2;
			EventPayload val2 = val;
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishIceExceptionsDrops(List<ItemDropChance> enchantments)
		{
			//IL_0022: 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_003c: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0070: Expected O, but got Unknown
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Fire);
			List<string> list = new List<string>();
			list.Add("Ice Witch");
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = specificParticleDrop;
			string item2 = LootManagerParamsHelper.Get(LootManagerParams.Faction).key;
			((Dictionary<string, object>)val)[item2] = (object)(Factions)2;
			string item3 = LootManagerParamsHelper.Get(LootManagerParams.ExceptNames).key;
			((Dictionary<string, object>)val)[item3] = list;
			EventPayload val2 = val;
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishWendigoDrops(List<ItemDropChance> enchantments)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_005c: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(5, 1, 1), new DropConfig(20, 1, 1), new DropConfig(10, 1, 3));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Ice, 30, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Wendigo";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 25);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishCrescentSharkDrops(List<ItemDropChance> enchantments)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_005c: Expected O, but got Unknown
			List<ItemDropChance> enchantmentIngrediantsDrops = DropFactory.GetEnchantmentIngrediantsDrops(new DropConfig(5, 1, 1), new DropConfig(20, 1, 1), new DropConfig(10, 1, 3));
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Ice, 15, 1, 1);
			enchantmentIngrediantsDrops.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Crescent Shark";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, enchantmentIngrediantsDrops, enchantments, 40);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishIceWitchDrops(List<ItemDropChance> enchantments)
		{
			//IL_001e: 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_003b: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0058: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Ice, 40, 1, 1);
			list.Add(specificParticleDrop);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Ice Witch";
			string item2 = LootManagerParamsHelper.Get(LootManagerParams.Faction).key;
			((Dictionary<string, object>)val)[item2] = (object)(Factions)2;
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 55);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishAncientDwellerDrops(List<ItemDropChance> enchantments)
		{
			//IL_0036: 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_0055: Expected O, but got Unknown
			//IL_0056: Expected O, but got Unknown
			ItemDropChance specificParticleDrop = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Either, 40, 1, 1);
			ItemDropChance specificParticleDrop2 = ItemDropHelpers.GetSpecificParticleDrop(ElementalParticles.Light, 40, 1, 1);
			List<ItemDropChance> list = new List<ItemDropChance>();
			list.Add(specificParticleDrop);
			list.Add(specificParticleDrop2);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = "Ancient Dweller";
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootByEnemyName", val2);
		}

		public static void PublishUniquesDrops(List<ItemDropChance> enchantments)
		{
			PublishBossesDrops(enchantments);
			PublishUniqueEnemyDrops(enchantments);
			PublishUncertainBossesDrops(enchantments);
			PublishUncertainUniqueEnemyDrops(enchantments);
		}

		public static void PublishUniqueEnemyDrops(List<ItemDropChance> enchantments)
		{
			//IL_0008: 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_0027: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0073: Expected O, but got Unknown
			List<ItemDropChance> guaranteedParticlesDrop = ItemDropHelpers.GetGuaranteedParticlesDrop(1, 1);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = true;
			string item2 = LootManagerParamsHelper.Get(LootManagerParams.MinDropCount).key;
			((Dictionary<string, object>)val)[item2] = 1;
			string item3 = LootManagerParamsHelper.Get(LootManagerParams.MaxDropCount).key;
			((Dictionary<string, object>)val)[item3] = 2;
			string item4 = LootManagerParamsHelper.Get(LootManagerParams.ListOfItemDropChances).key;
			((Dictionary<string, object>)val)[item4] = guaranteedParticlesDrop;
			EventPayload val2 = val;
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootForUniques", val2);
		}

		public static void PublishUncertainUniqueEnemyDrops(List<ItemDropChance> enchantments)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_007c: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			list.Add(ItemDropHelpers.GetTourmalineDrop());
			list.Add(ItemDropHelpers.GetPurifyingQuartzDrop());
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = true;
			string item2 = LootManagerParamsHelper.Get(LootManagerParams.MinDropCount).key;
			((Dictionary<string, object>)val)[item2] = 1;
			string item3 = LootManagerParamsHelper.Get(LootManagerParams.MaxDropCount).key;
			((Dictionary<string, object>)val)[item3] = 2;
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 33);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootForUniques", val2);
		}

		public static void PublishBossesDrops(List<ItemDropChance> enchantments)
		{
			//IL_0008: 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: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_003d: Expected O, but got Unknown
			List<ItemDropChance> guaranteedParticlesDrop = ItemDropHelpers.GetGuaranteedParticlesDrop();
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = guaranteedParticlesDrop;
			string item2 = LootManagerParamsHelper.Get(LootManagerParams.IsForBosses).key;
			((Dictionary<string, object>)val)[item2] = true;
			EventPayload val2 = val;
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootForUniques", val2);
		}

		public static void PublishUncertainBossesDrops(List<ItemDropChance> enchantments)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_007c: Expected O, but got Unknown
			List<ItemDropChance> list = new List<ItemDropChance>();
			list.Add(ItemDropHelpers.GetTourmalineDrop());
			list.Add(ItemDropHelpers.GetPurifyingQuartzDrop());
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = true;
			string item2 = LootManagerParamsHelper.Get(LootManagerParams.MinDropCount).key;
			((Dictionary<string, object>)val)[item2] = 1;
			string item3 = LootManagerParamsHelper.Get(LootManagerParams.MaxDropCount).key;
			((Dictionary<string, object>)val)[item3] = 2;
			EventPayload val2 = val;
			EventPayLoadHelpers.SetDistributedEnchantmentsToPayload(val2, list, enchantments, 10);
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLootForUniques", val2);
		}

		public static void PublishGlobalDrops()
		{
			PublishIncenseDrops();
			PublishIncenseDropsForUnique();
			PublishIncenseDropsForBosses();
		}

		public static void PublishIncenseDrops()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_0074: Expected O, but got Unknown
			List<ItemDropChance> incensesDrop = ItemDropHelpers.GetIncensesDrop();
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = true;
			string item2 = LootManagerParamsHelper.Get(LootManagerParams.MinDropCount).key;
			((Dictionary<string, object>)val)[item2] = 1;
			string item3 = LootManagerParamsHelper.Get(LootManagerParams.MaxDropCount).key;
			((Dictionary<string, object>)val)[item3] = 2;
			string item4 = LootManagerParamsHelper.Get(LootManagerParams.ListOfItemDropChances).key;
			((Dictionary<string, object>)val)[item4] = incensesDrop;
			EventPayload val2 = val;
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishIncenseDropsForBosses()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_0074: Expected O, but got Unknown
			List<ItemDropChance> incensesDrop = ItemDropHelpers.GetIncensesDrop(8);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = true;
			string item2 = LootManagerParamsHelper.Get(LootManagerParams.MinDropCount).key;
			((Dictionary<string, object>)val)[item2] = 1;
			string item3 = LootManagerParamsHelper.Get(LootManagerParams.MaxDropCount).key;
			((Dictionary<string, object>)val)[item3] = 2;
			string item4 = LootManagerParamsHelper.Get(LootManagerParams.ListOfItemDropChances).key;
			((Dictionary<string, object>)val)[item4] = incensesDrop;
			EventPayload val2 = val;
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishIncenseDropsForUnique()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_0074: Expected O, but got Unknown
			List<ItemDropChance> incensesDrop = ItemDropHelpers.GetIncensesDrop(5);
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = true;
			string item2 = LootManagerParamsHelper.Get(LootManagerParams.MinDropCount).key;
			((Dictionary<string, object>)val)[item2] = 1;
			string item3 = LootManagerParamsHelper.Get(LootManagerParams.MaxDropCount).key;
			((Dictionary<string, object>)val)[item3] = 2;
			string item4 = LootManagerParamsHelper.Get(LootManagerParams.ListOfItemDropChances).key;
			((Dictionary<string, object>)val)[item4] = incensesDrop;
			EventPayload val2 = val;
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "AddLoot", val2);
		}

		public static void PublishStoreLootsToXml()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			EventPayload val = new EventPayload();
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "LootRulesSerializer@SaveLootRulesToXml", val);
		}

		public static void PublishLoadLootsXml()
		{
			//IL_0000: 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_0028: Expected O, but got Unknown
			//IL_0029: Expected O, but got Unknown
			EventPayload val = new EventPayload { };
			string item;
			((Dictionary<string, object>)val)[item] = Path.Combine(OEBP.GetProjectLocation(), "MyLootOverrides.xml");
			EventPayload val2 = val;
			EventBus.Publish(OEBP.LOOT_MANAGER_ALL_GUID, "LootRulesSerializer@SaveLootRulesToXml", val2);
		}
	}
	public static class EventBusSubscriber
	{
	}
}

About

Contact Us Privacy Policy Thunderstore Wiki

Developers

API Docs GitHub Repo Package Format Docs Markdown Preview Manifest Validator

Thunderstore 2024