using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.CaptainSupplyDrop;
using EntityStates.Missions.RepurposedCrater;
using EntityStates.NewtMonster;
using EntityStates.Wisp1Monster;
using HG.Reflection;
using InLobbyConfig;
using InLobbyConfig.Fields;
using ItemStringParser;
using Microsoft.CodeAnalysis;
using On.EntityStates.CaptainSupplyDrop;
using On.EntityStates.Missions.RepurposedCrater;
using On.EntityStates.NewtMonster;
using On.RoR2;
using On.RoR2.Projectile;
using R2API.Utils;
using RoR2;
using RoR2.Artifacts;
using RoR2.CharacterAI;
using RoR2.Hologram;
using RoR2.Navigation;
using RoR2.Networking;
using RoR2.Projectile;
using RoR2.Scripts.GameBehaviors;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("BazaarIsMyHaven")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+b97861694253c4f1b3080898672b7303f5941aae")]
[assembly: AssemblyProduct("BazaarIsMyHaven")]
[assembly: AssemblyTitle("BazaarIsMyHaven")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BazaarIsMyHaven
{
	public abstract class BazaarBase
	{
		protected Random RNG = new Random();

		public abstract void Preload();

		public abstract void SetupBazaar();

		public virtual void Hook()
		{
		}

		public virtual void RunStart()
		{
		}

		public virtual void RunEnd()
		{
		}

		public virtual void AddDirectorCards(List<DirectorCard> cards)
		{
		}

		public virtual int CheckAfterSetup()
		{
			return 0;
		}

		public virtual void SpawnLatePicks()
		{
		}

		protected static GameObject SpawnAt(GameObject prefab, SpawnCardStruct slot)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(prefab, slot.Position, Quaternion.Euler(slot.Rotation));
			NetworkServer.Spawn(obj);
			return obj;
		}

		protected static List<GameObject> SpawnInSlots(Dictionary<int, SpawnCardStruct> slots, GameObject prefab, int start, int count)
		{
			List<GameObject> list = new List<GameObject>();
			for (int i = start; i < start + count; i++)
			{
				list.Add(SpawnAt(prefab, slots[i]));
			}
			return list;
		}

		public static void SpawnEffect(AsyncOperationHandle<GameObject> effect, Vector3 position, Color32 color, float scale = 1f)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			EffectManager.SpawnEffect(effect.WaitForCompletion(), new EffectData
			{
				origin = position,
				rotation = Quaternion.identity,
				scale = scale,
				color = color
			}, true);
		}

		protected bool IsCurrentMapInBazaar()
		{
			//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)
			Scene activeScene = SceneManager.GetActiveScene();
			return ((Scene)(ref activeScene)).name == "bazaar";
		}

		protected bool IsMultiplayer()
		{
			return PlayerCharacterMasterController.instances.Count > 1;
		}

		protected T GetRandom<T>(List<T> list, T defaultValue)
		{
			if (list == null || list.Count == 0)
			{
				return defaultValue;
			}
			return list[RNG.Next(list.Count)];
		}

		protected List<t> DisorderList<t>(List<t> TList)
		{
			List<t> list = new List<t>();
			foreach (t T in TList)
			{
				list.Insert(RNG.Next(list.Count()), T);
			}
			return list;
		}
	}
	public class BazaarCauldron : BazaarBase
	{
		private AsyncOperationHandle<GameObject> lunarCauldronWhiteToGreen;

		private AsyncOperationHandle<GameObject> lunarCauldronGreenToRed;

		private AsyncOperationHandle<GameObject> lunarCauldronRedToWhite;

		private AsyncOperationHandle<GameObject> transcendentCauldron;

		private AsyncOperationHandle<GameObject>[] LunarCauldronsCode;

		private Dictionary<int, SpawnCardStruct> DicCauldrons = new Dictionary<int, SpawnCardStruct>();

		private DirectorCard card;

		private int spawned;

		public override void Preload()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			lunarCauldronWhiteToGreen = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/LunarCauldrons/LunarCauldron, WhiteToGreen.prefab");
			lunarCauldronGreenToRed = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/LunarCauldrons/LunarCauldron, GreenToRed Variant.prefab");
			lunarCauldronRedToWhite = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/LunarCauldrons/LunarCauldron, RedToWhite Variant.prefab");
			transcendentCauldron = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC4/BetterCauldron.prefab");
			LunarCauldronsCode = new AsyncOperationHandle<GameObject>[4] { lunarCauldronWhiteToGreen, lunarCauldronGreenToRed, lunarCauldronRedToWhite, transcendentCauldron };
		}

		public override void Hook()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			PurchaseInteraction.Awake += new hook_Awake(PurchaseInteraction_Awake);
			PurchaseInteraction.OnInteractionBegin += new hook_OnInteractionBegin(PurchaseInteraction_OnInteractionBegin);
			ShopTerminalBehavior.SetPickup += new hook_SetPickup(ShopTerminalBehavior_SetPickup);
		}

		public override void RunStart()
		{
		}

		public override void AddDirectorCards(List<DirectorCard> cards)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			card = null;
			if (!ModConfig.CauldronSectionEnabled.Value)
			{
				return;
			}
			if (!GetRandomLunarCauldron().IsValid())
			{
				Log.LogWarning("No cauldron types with a valid weight; skipping cauldrons.");
				return;
			}
			card = new DirectorCard("Lunar Cauldron", ModConfig.CauldronDirectorCost, ModConfig.CauldronDirectorWeight, () => ModConfig.CauldronMaxAmount.Value);
			cards.Add(card);
		}

		public override void SetupBazaar()
		{
			if (card != null)
			{
				DicCauldrons.Clear();
				SetCauldron();
				spawned = 0;
				SpawnLatePicks();
			}
		}

		public override void SpawnLatePicks()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (card != null)
			{
				while (spawned < card.Count)
				{
					BazaarBase.SpawnAt(GetRandomLunarCauldron().WaitForCompletion(), DicCauldrons[spawned]);
					spawned++;
				}
			}
		}

		public void PurchaseInteraction_Awake(orig_Awake orig, PurchaseInteraction self)
		{
			orig.Invoke(self);
			if (ModConfig.EnableMod.Value && ModConfig.CauldronSectionEnabled.Value && IsCurrentMapInBazaar() && NetworkServer.active)
			{
				if (((Object)self).name.StartsWith("LunarCauldron, WhiteToGreen"))
				{
					self.cost = ModConfig.CauldronWhiteToGreenCost.Value;
					self.Networkcost = ModConfig.CauldronWhiteToGreenCost.Value;
				}
				if (((Object)self).name.StartsWith("LunarCauldron, GreenToRed"))
				{
					self.cost = ModConfig.CauldronGreenToRedCost.Value;
					self.Networkcost = ModConfig.CauldronGreenToRedCost.Value;
				}
				if (((Object)self).name.StartsWith("LunarCauldron, RedToWhite"))
				{
					self.cost = ModConfig.CauldronRedToWhiteCost.Value;
					self.Networkcost = ModConfig.CauldronRedToWhiteCost.Value;
				}
				if (((Object)self).name.StartsWith("BetterCauldron"))
				{
					self.cost = ModConfig.CauldronTranscendentCost.Value;
					self.Networkcost = ModConfig.CauldronTranscendentCost.Value;
				}
			}
		}

		public void PurchaseInteraction_OnInteractionBegin(orig_OnInteractionBegin orig, PurchaseInteraction self, Interactor activator)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Invalid comparison between Unknown and I4
			if (ModConfig.EnableMod.Value && ModConfig.CauldronSectionEnabled.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("LunarCauldron, RedToWhite Variant") && IsMultiplayer() && ModCompatibilityShareSuite.enabled && ModCompatibilityShareSuite.IsShareSuite_PrinterCauldronFixEnabled())
			{
				CharacterBody val = (Object.op_Implicit((Object)(object)activator) ? ((Component)activator).GetComponent<CharacterBody>() : null);
				Inventory inventory = (Object.op_Implicit((Object)(object)val) ? val.inventory : null);
				ShopTerminalBehavior component = ((Component)self).GetComponent<ShopTerminalBehavior>();
				PickupDef pickupDef = (Object.op_Implicit((Object)(object)component) ? PickupCatalog.GetPickupDef(component.CurrentPickup().pickupIndex) : null);
				if (Object.op_Implicit((Object)(object)inventory) && pickupDef != null && (int)pickupDef.itemIndex != -1)
				{
					bool compensated = false;
					UnityAction<PayCostContext, PayCostResults> val2 = delegate(PayCostContext context, PayCostResults results)
					{
						//IL_003b: Unknown result type (might be due to invalid IL or missing references)
						if (!compensated && (Object)(object)context.activator == (Object)(object)activator && Object.op_Implicit((Object)(object)inventory))
						{
							compensated = true;
							inventory.GiveItemPermanent(pickupDef.itemIndex, 2);
						}
					};
					((UnityEvent<PayCostContext, PayCostResults>)(object)self.onDetailedPurchaseServer).AddListener(val2);
					try
					{
						orig.Invoke(self, activator);
						return;
					}
					finally
					{
						((UnityEvent<PayCostContext, PayCostResults>)(object)self.onDetailedPurchaseServer).RemoveListener(val2);
					}
				}
			}
			orig.Invoke(self, activator);
		}

		public void ShopTerminalBehavior_SetPickup(orig_SetPickup orig, ShopTerminalBehavior self, UniquePickup newPickup, bool newHidden)
		{
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.EnableMod.Value && ModConfig.CauldronSectionEnabled.Value && IsCurrentMapInBazaar() && NetworkServer.active)
			{
				if (((Object)self).name.StartsWith("LunarCauldronGreen"))
				{
					CauldronHacked_SetPickupIndex(self, out var listLunarItem);
					if (listLunarItem.Count > 0)
					{
						newPickup.pickupIndex = listLunarItem[RNG.Next(0, listLunarItem.Count)];
					}
				}
				if (((Object)self).name.StartsWith("LunarCauldronRed"))
				{
					CauldronHacked_SetPickupIndex(self, out var listLunarItem2);
					if (listLunarItem2.Count > 0)
					{
						newPickup.pickupIndex = listLunarItem2[RNG.Next(0, listLunarItem2.Count)];
					}
				}
				if (((Object)self).name.StartsWith("LunarCauldronWhite"))
				{
					CauldronHacked_SetPickupIndex(self, out var listLunarItem3);
					if (listLunarItem3.Count > 0)
					{
						newPickup.pickupIndex = listLunarItem3[RNG.Next(0, listLunarItem3.Count)];
					}
				}
			}
			orig.Invoke(self, newPickup, newHidden);
		}

		private void SetCauldron()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = new List<int> { 0, 1, 2, 3, 4, 5, 6 };
			List<int> list2 = new List<int>();
			while (list.Count > 0)
			{
				int index = RNG.Next(list.Count);
				list2.Add(list[index]);
				list.RemoveAt(index);
			}
			DicCauldrons.Add(list2[0], new SpawnCardStruct(new Vector3(-115.9816f, -24.1175f, -6.2091f), new Vector3(0f, 120f, 0f)));
			DicCauldrons.Add(list2[1], new SpawnCardStruct(new Vector3(-119.928f, -24.1238f, -7.0865f), new Vector3(0f, 140f, 0f)));
			DicCauldrons.Add(list2[2], new SpawnCardStruct(new Vector3(-123.4725f, -23.7951f, -5.469f), new Vector3(0f, 160f, 0f)));
			DicCauldrons.Add(list2[3], new SpawnCardStruct(new Vector3(-107.8159f, -23.8448f, -4.517f), new Vector3(0f, 130f, 0f)));
			DicCauldrons.Add(list2[4], new SpawnCardStruct(new Vector3(-101.2425f, -24.8612f, -9.1464f), new Vector3(0f, 160f, 0f)));
			DicCauldrons.Add(list2[5], new SpawnCardStruct(new Vector3(-98.5219f, -25.6548f, -12.3659f), new Vector3(0f, 155f, 0f)));
			DicCauldrons.Add(list2[6], new SpawnCardStruct(new Vector3(-94.6071f, -25.8717f, -13.6159f), new Vector3(0f, 135f, 0f)));
		}

		private void CauldronHacked_SetPickupIndex(ShopTerminalBehavior self, out List<PickupIndex> listLunarItem)
		{
			listLunarItem = new List<PickupIndex>();
			if (((Object)self).name.EndsWith("Yellow"))
			{
				listLunarItem.AddRange(Run.instance.availableBossDropList);
			}
			if (((Object)self).name.EndsWith("Blue"))
			{
				listLunarItem.AddRange(Run.instance.availableLunarItemDropList);
			}
			if (((Object)self).name.EndsWith("Purple"))
			{
				listLunarItem.AddRange(Run.instance.availableVoidTier1DropList);
				listLunarItem.AddRange(Run.instance.availableVoidTier2DropList);
				listLunarItem.AddRange(Run.instance.availableVoidTier3DropList);
				listLunarItem.AddRange(Run.instance.availableVoidBossDropList);
			}
		}

		private AsyncOperationHandle<GameObject> GetRandomLunarCauldron()
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			float num = ModConfig.CauldronWhiteToGreenWeight.Value;
			float num2 = ModConfig.CauldronGreenToRedWeight.Value;
			float num3 = ModConfig.CauldronRedToWhiteWeight.Value;
			float num4 = ((Object.op_Implicit((Object)(object)DLC4Content.DLC4) && Run.instance.IsExpansionEnabled(DLC4Content.DLC4)) ? ModConfig.CauldronTranscendentWeight.Value : 0f);
			if (num < 0f)
			{
				num = 0f;
			}
			if (num2 < 0f)
			{
				num2 = 0f;
			}
			if (num3 < 0f)
			{
				num3 = 0f;
			}
			if (num4 < 0f)
			{
				num4 = 0f;
			}
			float num5 = num + num2 + num3 + num4;
			if (num5 == 0f)
			{
				return default(AsyncOperationHandle<GameObject>);
			}
			double num6 = RNG.NextDouble() * (double)num5;
			if (num6 < (double)num)
			{
				return LunarCauldronsCode[0];
			}
			if (num6 < (double)(num + num2))
			{
				return LunarCauldronsCode[1];
			}
			if (num6 < (double)(num + num2 + num3))
			{
				return LunarCauldronsCode[2];
			}
			return LunarCauldronsCode[3];
		}
	}
	public class BazaarCleansingPool : BazaarBase
	{
		private AsyncOperationHandle<InteractableSpawnCard> iscShrineCleanse;

		private AsyncOperationHandle<GameObject> lunarShopTerminal;

		private Dictionary<int, SpawnCardStruct> DicLunarPools = new Dictionary<int, SpawnCardStruct>();

		private DirectorCard card;

		private bool spawned;

		private GameObject pool;

		private GameObject hoveringCoin;

		public override void Preload()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			iscShrineCleanse = Addressables.LoadAssetAsync<InteractableSpawnCard>((object)"RoR2/Base/ShrineCleanse/iscShrineCleanse.asset");
			lunarShopTerminal = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/LunarShopTerminal/LunarShopTerminal.prefab");
		}

		public override void Hook()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			ShopTerminalBehavior.SetPickup += new hook_SetPickup(ShopTerminalBehavior_SetPickup);
		}

		public override void RunStart()
		{
		}

		public override void AddDirectorCards(List<DirectorCard> cards)
		{
			card = null;
			if (ModConfig.CleansingPoolSectionEnabled.Value)
			{
				card = new DirectorCard("Cleansing Pool", ModConfig.CleansingPoolDirectorCost, ModConfig.CleansingPoolDirectorWeight, () => 1);
				cards.Add(card);
			}
		}

		public override void SetupBazaar()
		{
			spawned = false;
			pool = null;
			hoveringCoin = null;
			SpawnLatePicks();
		}

		public override void SpawnLatePicks()
		{
			if (card != null && card.Count != 0 && !spawned)
			{
				SpawnShrineCleanse();
				spawned = true;
			}
		}

		private void ShopTerminalBehavior_SetPickup(orig_SetPickup orig, ShopTerminalBehavior self, UniquePickup newPickup, bool newHidden)
		{
			//IL_00a0: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.CleansingPoolRewardsLunarCoins.Value && NetworkServer.active && Object.op_Implicit((Object)(object)self))
			{
				if (Object.op_Implicit((Object)(object)pool) && (Object)(object)((Component)self).gameObject == (Object)(object)pool)
				{
					newPickup.pickupIndex = PickupCatalog.FindPickupIndex(MiscPickups.LunarCoin.miscPickupIndex);
				}
				if (Object.op_Implicit((Object)(object)hoveringCoin) && (Object)(object)((Component)self).gameObject == (Object)(object)hoveringCoin)
				{
					newPickup.pickupIndex = PickupCatalog.FindPickupIndex(MiscPickups.LunarCoin.miscPickupIndex);
					((Component)self).gameObject.GetComponent<PurchaseInteraction>().SetAvailable(false);
				}
			}
			orig.Invoke(self, newPickup, newHidden);
		}

		private void SpawnShrineCleanse()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			DicLunarPools.Clear();
			SetLunarPool();
			pool = BazaarBase.SpawnAt(((SpawnCard)iscShrineCleanse.WaitForCompletion()).prefab, DicLunarPools[0]);
			if (ModConfig.CleansingPoolRewardsLunarCoins.Value)
			{
				GameObject val = Object.Instantiate<GameObject>(lunarShopTerminal.WaitForCompletion(), DicLunarPools[0].Position, Quaternion.identity);
				val.transform.localPosition = new Vector3(DicLunarPools[0].Position.x, DicLunarPools[0].Position.y + 0.5f, DicLunarPools[0].Position.z);
				val.transform.eulerAngles = DicLunarPools[0].Rotation;
				((Object)val).name = "HoveringLunarCoin";
				hoveringCoin = val;
				NetworkServer.Spawn(val);
			}
		}

		private void SetLunarPool()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			DicLunarPools.Add(0, new SpawnCardStruct(new Vector3(-71.5092f, -25.5622f, -44.2288f), new Vector3(6.4123f, 0f, 356.459f)));
		}
	}
	public class BazaarCommandPedestal : BazaarBase
	{
		private class Essence
		{
			public CharacterMaster owner;

			public Vector3 vaultPosition;
		}

		private class CommandPedestalCard : DirectorCard
		{
			public ModConfig.CommandPedestalTier tier;

			public override float Weight
			{
				get
				{
					if (GetTiers().Count <= 0)
					{
						return 0f;
					}
					return base.Weight;
				}
			}

			public CommandPedestalCard()
				: base("Command Pedestal", null, ModConfig.CommandPedestalDirectorWeight, () => 1)
			{
			}

			private static List<ModConfig.CommandPedestalTier> GetTiers()
			{
				return ModConfig.CommandPedestalTiers.Where((ModConfig.CommandPedestalTier tier) => tier.weight.Value > 0f && tier.dropList(Run.instance).Count > 0).ToList();
			}

			protected override int CheapestCost()
			{
				List<ModConfig.CommandPedestalTier> tiers = GetTiers();
				if (tiers.Count != 0)
				{
					return tiers.Min((ModConfig.CommandPedestalTier tier) => Math.Max(0, tier.directorCost.Value));
				}
				return int.MaxValue;
			}

			protected override int PickCost(int credits)
			{
				WeightedSelection<ModConfig.CommandPedestalTier> val = new WeightedSelection<ModConfig.CommandPedestalTier>(8);
				foreach (ModConfig.CommandPedestalTier tier in GetTiers())
				{
					if (Math.Max(0, tier.directorCost.Value) <= credits)
					{
						val.AddChoice(tier, tier.weight.Value);
					}
				}
				this.tier = val.Evaluate(Random.value);
				return Math.Max(0, this.tier.directorCost.Value);
			}
		}

		private const float SignHeight = 4.5f;

		private const float HiddenEssenceDepth = 5f;

		private const float DisplayDropHeight = 5f;

		private AsyncOperationHandle<GameObject> vaultPrefab;

		private AsyncOperationHandle<GameObject> shrineUseEffect;

		private CommandPedestalCard card;

		private bool spawned;

		private GameObject pedestal;

		private Xoroshiro128Plus rng;

		private bool sold;

		private UniquePickup offer;

		private bool hasOffer;

		private GameObject displayEssence;

		private readonly HashSet<PlayerCharacterMasterController> buyers = new HashSet<PlayerCharacterMasterController>();

		private readonly Dictionary<PickupPickerController, Essence> essences = new Dictionary<PickupPickerController, Essence>();

		private readonly Dictionary<PlayerCharacterMasterController, EquipmentIndex> storedEquipment = new Dictionary<PlayerCharacterMasterController, EquipmentIndex>();

		public static BazaarCommandPedestal instance;

		public BazaarCommandPedestal()
		{
			instance = this;
		}

		public IEnumerable<PickupIndex> GetChoicesFor(PlayerCharacterMasterController player)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)pedestal) || !hasOffer || sold || (ModConfig.CommandPedestalInstancedPurchases.Value && buyers.Contains(player)))
			{
				return Enumerable.Empty<PickupIndex>();
			}
			IEnumerable<PickupIndex> availableGroupFromPickupIndex = PickupTransmutationManager.GetAvailableGroupFromPickupIndex(offer.pickupIndex);
			return availableGroupFromPickupIndex ?? Enumerable.Empty<PickupIndex>();
		}

		public override void Preload()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			vaultPrefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC3/PowerOrbPedestal/PowerOrbVault.prefab");
			shrineUseEffect = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/VFX/ShrineUseEffect.prefab");
			PriceSigns.Preload();
		}

		public override void Hook()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			PowerOrbPedestalManager.DoOnInteract += new hook_DoOnInteract(PowerOrbPedestalManager_DoOnInteract);
			GenericInteraction.RoR2_IInteractable_GetInteractability += new hook_RoR2_IInteractable_GetInteractability(GenericInteraction_GetInteractability);
			PickupPickerController.GetInteractability += new hook_GetInteractability(PickupPickerController_GetInteractability);
			PickupPickerController.CreatePickup_UniquePickup += new hook_CreatePickup_UniquePickup(PickupPickerController_CreatePickup);
		}

		public override void AddDirectorCards(List<DirectorCard> cards)
		{
			card = null;
			if (ModConfig.CommandPedestalSectionEnabled.Value)
			{
				card = new CommandPedestalCard();
				cards.Add(card);
			}
		}

		public override void SetupBazaar()
		{
			spawned = false;
			pedestal = null;
			displayEssence = null;
			hasOffer = false;
			sold = false;
			buyers.Clear();
			essences.Clear();
			storedEquipment.Clear();
			SpawnLatePicks();
		}

		public override void SpawnLatePicks()
		{
			if (card != null && card.Count != 0 && !spawned)
			{
				SpawnCommandPedestal();
				spawned = true;
			}
		}

		private bool IsBazaarChest(Component component)
		{
			if (Object.op_Implicit((Object)(object)pedestal) && Object.op_Implicit((Object)(object)component) && (Object)(object)component.gameObject == (Object)(object)pedestal)
			{
				return NetworkServer.active;
			}
			return false;
		}

		private static PlayerCharacterMasterController GetPlayer(GameObject bodyObject)
		{
			CharacterBody val = (Object.op_Implicit((Object)(object)bodyObject) ? bodyObject.GetComponent<CharacterBody>() : null);
			if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val.master))
			{
				return null;
			}
			return val.master.playerCharacterMasterController;
		}

		private void PowerOrbPedestalManager_DoOnInteract(orig_DoOnInteract orig, PowerOrbPedestalManager self, GameObject interactorObject)
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			if (!IsBazaarChest((Component)(object)self))
			{
				orig.Invoke(self, interactorObject);
				return;
			}
			Interactor val = (Object.op_Implicit((Object)(object)interactorObject) ? interactorObject.GetComponent<Interactor>() : null);
			CharacterBody val2 = (Object.op_Implicit((Object)(object)interactorObject) ? interactorObject.GetComponent<CharacterBody>() : null);
			PlayerCharacterMasterController player = GetPlayer(interactorObject);
			if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val2) || !Object.op_Implicit((Object)(object)player))
			{
				return;
			}
			if (storedEquipment.ContainsKey(player))
			{
				SwapStoredEquipment(self, player, val2);
			}
			else
			{
				if (sold || (ModConfig.CommandPedestalInstancedPurchases.Value && buyers.Contains(player)))
				{
					return;
				}
				CostTypeIndex value = ModConfig.CommandPedestalCostType.Value;
				int price = GetPrice();
				if (!Helper.CanAfford(value, price, val, val2))
				{
					Refuse(self);
				}
				else if (ModConfig.CommandPedestalBuyToInventory.Value)
				{
					if (TryGetWaitingEssence(val2.master, out var picker))
					{
						picker.OnInteractionBegin(val);
					}
					else if (hasOffer)
					{
						SpawnHiddenEssence(self, offer, val);
					}
					else
					{
						Refuse(self);
					}
				}
				else if (!hasOffer)
				{
					Refuse(self);
				}
				else
				{
					Helper.PayCost(value, price, val, val2, pedestal, rng);
					CompletePurchase(self, player);
					DropEssence(self, offer);
				}
			}
		}

		private static void Refuse(PowerOrbPedestalManager vault)
		{
			vault.DoInteractResult(false);
			vault.CallRpcInteractResult(false);
		}

		private void CompletePurchase(PowerOrbPedestalManager vault, PlayerCharacterMasterController player)
		{
			if (ModConfig.CommandPedestalInstancedPurchases.Value)
			{
				buyers.Add(player);
				UpdateSwapAvailability(player);
				HideDisplayFor(player);
				PriceSigns.HideFor(pedestal, player);
				PlayBuyEffect(vault);
				return;
			}
			sold = true;
			if (Object.op_Implicit((Object)(object)displayEssence))
			{
				NetworkServer.Destroy(displayEssence);
			}
			vault.DoInteractResult(true);
			vault.CallRpcInteractResult(true);
			if (storedEquipment.ContainsKey(player))
			{
				((MonoBehaviour)Main.instance).StartCoroutine(UpdateSwapAvailabilityLater(player));
			}
			foreach (PickupPickerController key in essences.Keys)
			{
				if (Object.op_Implicit((Object)(object)key))
				{
					NetworkServer.Destroy(((Component)key).gameObject);
				}
			}
			essences.Clear();
		}

		private void PlayBuyEffect(PowerOrbPedestalManager vault)
		{
			//IL_0020: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = (Object.op_Implicit((Object)(object)vault.activationEffectAttach) ? vault.activationEffectAttach.position : ((Component)vault).transform.position);
			if (Object.op_Implicit((Object)(object)vault.activationEffectPrefab))
			{
				EffectManager.SpawnEffect(vault.activationEffectPrefab, new EffectData
				{
					origin = val
				}, true);
			}
			PickupDef pickupDef = PickupCatalog.GetPickupDef(offer.pickupIndex);
			BazaarBase.SpawnEffect(shrineUseEffect, val, Color32.op_Implicit(pickupDef?.baseColor ?? Color.white));
		}

		private bool TryGetWaitingEssence(CharacterMaster master, out PickupPickerController picker)
		{
			foreach (KeyValuePair<PickupPickerController, Essence> essence in essences)
			{
				if (Object.op_Implicit((Object)(object)essence.Key) && (Object)(object)essence.Value.owner == (Object)(object)master)
				{
					picker = essence.Key;
					return true;
				}
			}
			picker = null;
			return false;
		}

		private Interactability GenericInteraction_GetInteractability(orig_RoR2_IInteractable_GetInteractability orig, GenericInteraction self, Interactor activator)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if (IsBazaarChest((Component)(object)self) && Object.op_Implicit((Object)(object)activator))
			{
				CharacterBody component = ((Component)activator).GetComponent<CharacterBody>();
				if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component.master) && TryGetWaitingEssence(component.master, out var _))
				{
					return (Interactability)2;
				}
				PlayerCharacterMasterController player = GetPlayer(((Component)activator).gameObject);
				if (Object.op_Implicit((Object)(object)player) && storedEquipment.ContainsKey(player))
				{
					return (Interactability)2;
				}
				if (buyers.Contains(player))
				{
					return (Interactability)0;
				}
			}
			return orig.Invoke(self, activator);
		}

		private void SetInteractabilityForClient(PlayerCharacterMasterController player, Interactability interactability)
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			NetworkConnection val = (Object.op_Implicit((Object)(object)player.networkUser) ? ((NetworkBehaviour)player.networkUser).connectionToClient : null);
			NetworkIdentity component = pedestal.GetComponent<NetworkIdentity>();
			GenericInteraction component2 = pedestal.GetComponent<GenericInteraction>();
			if (val == null || !val.isReady || Util.ConnectionIsLocal(val) || !Object.op_Implicit((Object)(object)component) || !Object.op_Implicit((Object)(object)component2))
			{
				return;
			}
			int networkChannel = ((NetworkBehaviour)component2).GetNetworkChannel();
			NetworkWriter val2 = new NetworkWriter();
			val2.StartMessage((short)8);
			val2.Write(component.netId);
			Interactability interactability2 = component2.interactability;
			try
			{
				component2.interactability = interactability;
				NetworkBehaviour[] behavioursOfSameChannel = component.GetBehavioursOfSameChannel(networkChannel, false);
				foreach (NetworkBehaviour val3 in behavioursOfSameChannel)
				{
					uint syncVarDirtyBits = val3.m_SyncVarDirtyBits;
					try
					{
						val3.m_SyncVarDirtyBits = (((Object)(object)val3 == (Object)(object)component2) ? 1u : 0u);
						val3.OnSerialize(val2, false);
					}
					finally
					{
						val3.m_SyncVarDirtyBits = syncVarDirtyBits;
					}
				}
			}
			finally
			{
				component2.interactability = interactability2;
			}
			val2.FinishMessage();
			if (!val.SendWriter(val2, networkChannel))
			{
				Log.LogWarning("Could not update the Command Pedestal for a client.");
			}
		}

		private int GetPrice()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (card == null || card.tier == null)
			{
				return 0;
			}
			return Helper.GetCost(card.tier.cost.Value, ModConfig.CommandPedestalCostType.Value);
		}

		private bool TryRollPickup(out UniquePickup pickup)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			List<PickupIndex> list = ((card != null && card.tier != null) ? card.tier.dropList(Run.instance) : null);
			if (list == null || list.Count == 0)
			{
				pickup = UniquePickup.none;
				return false;
			}
			pickup = new UniquePickup(rng.NextElementUniform<PickupIndex>(list));
			return true;
		}

		private static Vector3 GetEssencePosition(PowerOrbPedestalManager vault)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			return (Object.op_Implicit((Object)(object)vault.activationEffectAttach) ? vault.activationEffectAttach : ((Component)vault).transform).position + Vector3.up;
		}

		private static void DropEssence(PowerOrbPedestalManager vault, UniquePickup pickup)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			Vector3 essencePosition = GetEssencePosition(vault);
			CreatePickupInfo val = default(CreatePickupInfo);
			((CreatePickupInfo)(ref val)).pickup = pickup;
			val.position = essencePosition;
			val.artifactFlag = (PickupArtifactFlag)1;
			PickupDropletController.CreatePickupDroplet(val, essencePosition, Vector3.up * 20f + ((Component)vault).transform.forward * 2f);
		}

		private void SpawnHiddenEssence(PowerOrbPedestalManager vault, UniquePickup pickup, Interactor activator)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Object.Instantiate<GameObject>(CommandArtifactManager.commandCubePrefab, ((Component)vault).transform.position + Vector3.down * 5f, Quaternion.identity);
			obj.GetComponent<PickupIndexNetworker>().NetworkpickupState = pickup;
			PickupPickerController component = obj.GetComponent<PickupPickerController>();
			component.SetOptionsFromPickupForCommandArtifact(pickup);
			component.pickupThatGeneratedOptions = pickup;
			Rigidbody val = default(Rigidbody);
			if (obj.TryGetComponent<Rigidbody>(ref val))
			{
				val.isKinematic = true;
			}
			NetworkServer.Spawn(obj);
			CharacterBody component2 = ((Component)activator).GetComponent<CharacterBody>();
			essences[component] = new Essence
			{
				owner = (Object.op_Implicit((Object)(object)component2) ? component2.master : null),
				vaultPosition = GetEssencePosition(vault)
			};
			component.OnInteractionBegin(activator);
		}

		private Interactability PickupPickerController_GetInteractability(orig_GetInteractability orig, PickupPickerController self, Interactor activator)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkServer.active && essences.TryGetValue(self, out var value) && Object.op_Implicit((Object)(object)value.owner))
			{
				CharacterBody val = (Object.op_Implicit((Object)(object)activator) ? ((Component)activator).GetComponent<CharacterBody>() : null);
				if (!Object.op_Implicit((Object)(object)val) || (Object)(object)val.master != (Object)(object)value.owner)
				{
					return (Interactability)0;
				}
			}
			return orig.Invoke(self, activator);
		}

		private void PickupPickerController_CreatePickup(orig_CreatePickup_UniquePickup orig, PickupPickerController self, UniquePickup pickupState)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active || !essences.TryGetValue(self, out var value))
			{
				orig.Invoke(self, pickupState);
				return;
			}
			essences.Remove(self);
			CharacterMaster val = (Object.op_Implicit((Object)(object)self.networkUIPromptController) ? self.networkUIPromptController.currentParticipantMaster : null);
			CharacterBody val2 = (Object.op_Implicit((Object)(object)val) ? val.GetBody() : null);
			Interactor val3 = (Object.op_Implicit((Object)(object)val2) ? ((Component)val2).GetComponent<Interactor>() : null);
			PlayerCharacterMasterController val4 = (Object.op_Implicit((Object)(object)val) ? val.playerCharacterMasterController : null);
			PowerOrbPedestalManager val5 = (Object.op_Implicit((Object)(object)pedestal) ? pedestal.GetComponent<PowerOrbPedestalManager>() : null);
			CostTypeIndex value2 = ModConfig.CommandPedestalCostType.Value;
			int price = GetPrice();
			if (!Object.op_Implicit((Object)(object)val5) || !Object.op_Implicit((Object)(object)val2) || !Object.op_Implicit((Object)(object)val2.inventory) || !Object.op_Implicit((Object)(object)val3) || !Object.op_Implicit((Object)(object)val4) || sold || (ModConfig.CommandPedestalInstancedPurchases.Value && buyers.Contains(val4)) || !Helper.CanAfford(value2, price, val3, val2))
			{
				if (Object.op_Implicit((Object)(object)val5))
				{
					Refuse(val5);
				}
			}
			else
			{
				Helper.PayCost(value2, price, val3, val2, pedestal, rng);
				GiveAndStore(val2, val4, pickupState.pickupIndex, value.vaultPosition);
				CompletePurchase(val5, val4);
			}
		}

		private void GiveAndStore(CharacterBody body, PlayerCharacterMasterController player, PickupIndex pickupIndex, Vector3 vaultPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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)
			EquipmentIndex val = Helper.GivePickup(body, pickupIndex, vaultPosition, dropReplacedEquipmentAsPickupDroplet: false);
			if ((int)val == -1)
			{
				storedEquipment.Remove(player);
				return;
			}
			storedEquipment[player] = val;
			Helper.CreateItemTakenOrb(body.corePosition, pedestal, PickupCatalog.FindPickupIndex(val));
		}

		private void SwapStoredEquipment(PowerOrbPedestalManager vault, PlayerCharacterMasterController player, CharacterBody body)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			EquipmentIndex val = storedEquipment[player];
			storedEquipment.Remove(player);
			GiveAndStore(body, player, PickupCatalog.FindPickupIndex(val), GetEssencePosition(vault));
			UpdateSwapAvailability(player);
		}

		private void UpdateSwapAvailability(PlayerCharacterMasterController player)
		{
			SetInteractabilityForClient(player, (Interactability)(storedEquipment.ContainsKey(player) ? 2 : 0));
		}

		private IEnumerator UpdateSwapAvailabilityLater(PlayerCharacterMasterController player)
		{
			yield return (object)new WaitForSecondsRealtime(0.5f);
			if (Object.op_Implicit((Object)(object)pedestal) && Object.op_Implicit((Object)(object)player))
			{
				UpdateSwapAvailability(player);
			}
		}

		private void HideDisplayFor(PlayerCharacterMasterController player)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			NetworkIdentity val = (Object.op_Implicit((Object)(object)displayEssence) ? displayEssence.GetComponent<NetworkIdentity>() : null);
			NetworkConnection val2 = (Object.op_Implicit((Object)(object)player.networkUser) ? ((NetworkBehaviour)player.networkUser).connectionToClient : null);
			if (!Object.op_Implicit((Object)(object)val) || val2 == null)
			{
				return;
			}
			if (Util.ConnectionIsLocal(val2))
			{
				Transform val3 = displayEssence.transform.Find("PickupDisplay");
				if (Object.op_Implicit((Object)(object)val3))
				{
					((Component)val3).gameObject.SetActive(false);
				}
				return;
			}
			NetworkWriter val4 = new NetworkWriter();
			val4.StartMessage((short)1);
			val4.Write(val.netId);
			val4.FinishMessage();
			if (!val2.SendWriter(val4, QosChannelIndex.defaultReliable.intVal))
			{
				Log.LogWarning("Could not hide the Command Pedestal's essence for a client.");
			}
		}

		private void SpawnDisplayEssence()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			GameObject commandCubePrefab = CommandArtifactManager.commandCubePrefab;
			SphereCollider val = (Object.op_Implicit((Object)(object)commandCubePrefab) ? commandCubePrefab.GetComponent<SphereCollider>() : null);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < 32; i++)
			{
				if (!Physics.GetIgnoreLayerCollision(commandCubePrefab.layer, i))
				{
					num |= 1 << i;
				}
			}
			Vector3 val2 = pedestal.transform.position + Vector3.up * 5f;
			RaycastHit val3 = default(RaycastHit);
			if (!Physics.SphereCast(val2, val.radius, Vector3.down, ref val3, 10f, num, (QueryTriggerInteraction)1))
			{
				Log.LogWarning("Found nothing for the Command Pedestal's essence to rest on.");
				return;
			}
			displayEssence = Object.Instantiate<GameObject>(commandCubePrefab, val2 + Vector3.down * ((RaycastHit)(ref val3)).distance, Quaternion.identity);
			displayEssence.GetComponent<PickupIndexNetworker>().NetworkpickupState = offer;
			displayEssence.GetComponent<PickupPickerController>().SetAvailable(false);
			Rigidbody val4 = default(Rigidbody);
			if (displayEssence.TryGetComponent<Rigidbody>(ref val4))
			{
				val4.isKinematic = true;
			}
			NetworkServer.Spawn(displayEssence);
			Log.LogDebug($"The Command Pedestal's essence rests on {((Object)((RaycastHit)(ref val3)).collider).name}, {displayEssence.transform.position.y - pedestal.transform.position.y:0.00} m above the pedestal.");
		}

		private void SpawnCommandPedestal()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			rng = new Xoroshiro128Plus(Run.instance.treasureRng.nextUlong);
			pedestal = Object.Instantiate<GameObject>(vaultPrefab.WaitForCompletion(), new Vector3(-63.9613f, -26.3518f, -73.8056f), Quaternion.Euler(0f, 300f, 0f));
			NetworkServer.Spawn(pedestal);
			hasOffer = TryRollPickup(out offer);
			if (hasOffer)
			{
				SpawnDisplayEssence();
			}
			Log.LogDebug("The Command Pedestal offers " + card.tier.name + ".");
			PriceSigns.Apply(new List<GameObject> { pedestal }, GetPrice(), ModConfig.CommandPedestalCostType.Value, 4.5f);
		}
	}
	public class BazaarDecorate : BazaarBase
	{
		private AsyncOperationHandle<GameObject> TeleporterBeaconEffect;

		public override void Preload()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			TeleporterBeaconEffect = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Junk/Teleporter/TeleporterBeaconEffect.prefab");
		}

		public override void Hook()
		{
		}

		public override void RunStart()
		{
		}

		public override void SetupBazaar()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			BazaarBase.SpawnEffect(TeleporterBeaconEffect, new Vector3(-73.5143f, -22.2897f, 9.1621f), Color32.op_Implicit(Color.blue));
			BazaarBase.SpawnEffect(TeleporterBeaconEffect, new Vector3(-57.0645f, -22.2698f, -0.5218f), Color32.op_Implicit(Color.blue));
			BazaarBase.SpawnEffect(TeleporterBeaconEffect, new Vector3(15.7063f, -2.1074f, 2.5406f), Color32.op_Implicit(Color.blue));
			BazaarBase.SpawnEffect(TeleporterBeaconEffect, new Vector3(2.5543f, -2.7093f, -8.7185f), Color32.op_Implicit(Color.blue));
		}
	}
	public class DirectorCard
	{
		public readonly string name;

		public readonly bool allowLatePicks;

		private readonly ConfigEntry<int> cost;

		private readonly ConfigEntry<float> weight;

		private readonly Func<int> maxCount;

		private readonly Func<bool> isAvailable;

		public int Count { get; private set; }

		public int Spent { get; private set; }

		public virtual float Weight => Mathf.Max(0f, weight.Value);

		public DirectorCard(string name, ConfigEntry<int> cost, ConfigEntry<float> weight, Func<int> maxCount, Func<bool> isAvailable = null, bool allowLatePicks = true)
		{
			this.name = name;
			this.cost = cost;
			this.weight = weight;
			this.maxCount = maxCount;
			this.isAvailable = isAvailable;
			this.allowLatePicks = allowLatePicks;
		}

		public bool CanPick(int credits)
		{
			if (Weight > 0f && Count < maxCount() && (isAvailable == null || isAvailable()))
			{
				return CheapestCost() <= credits;
			}
			return false;
		}

		public int Pick(int credits)
		{
			int num = PickCost(credits);
			Count++;
			Spent += num;
			return num;
		}

		protected virtual int CheapestCost()
		{
			return Math.Max(0, cost.Value);
		}

		protected virtual int PickCost(int credits)
		{
			return CheapestCost();
		}
	}
	public class BazaarDirector : MonoBehaviour
	{
		private static readonly Random random = new Random();

		private List<BazaarBase> sections;

		private List<DirectorCard> cards;

		private int credits;

		public static int Credits
		{
			get
			{
				int num = ModConfig.DirectorExtraCredits.Value + ModConfig.DirectorCreditsPerStage.Value * Run.instance.stageClearCount;
				if (ModConfig.DirectorCreditsCap.Value < 0)
				{
					return num;
				}
				return Math.Min(num, ModConfig.DirectorCreditsCap.Value);
			}
		}

		public static int Spend(int credits, IEnumerable<DirectorCard> cards, string round)
		{
			List<DirectorCard> source = cards.ToList();
			Dictionary<DirectorCard, int> dictionary = new Dictionary<DirectorCard, int>();
			int num = credits;
			while (true)
			{
				List<DirectorCard> list = source.Where((DirectorCard card) => card.CanPick(credits)).ToList();
				if (list.Count == 0)
				{
					break;
				}
				double num2 = random.NextDouble() * (double)list.Sum((DirectorCard card) => card.Weight);
				DirectorCard directorCard = list[list.Count - 1];
				foreach (DirectorCard item in list)
				{
					if (num2 < (double)item.Weight)
					{
						directorCard = item;
						break;
					}
					num2 -= (double)item.Weight;
				}
				credits -= directorCard.Pick(credits);
				dictionary[directorCard] = dictionary.GetValueOrDefault(directorCard) + 1;
			}
			string text = ((dictionary.Count == 0) ? "nothing" : string.Join(", ", dictionary.Select((KeyValuePair<DirectorCard, int> pick) => $"{pick.Value}x {pick.Key.name}")));
			Log.LogInfo($"Director ({round}): {num} credits bought {text}; {credits} left.");
			return credits;
		}

		public static void Create(List<BazaarBase> sections, List<DirectorCard> cards, int credits)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			BazaarDirector bazaarDirector = new GameObject("BazaarDirector").AddComponent<BazaarDirector>();
			bazaarDirector.sections = sections;
			bazaarDirector.cards = cards;
			bazaarDirector.credits = credits;
		}

		private IEnumerator Start()
		{
			yield return null;
			if (!NetworkServer.active)
			{
				yield break;
			}
			int num = 0;
			foreach (BazaarBase section in sections)
			{
				try
				{
					num += section.CheckAfterSetup();
				}
				catch (Exception arg)
				{
					Log.LogError($"Could not check {section.GetType().Name} after setup: {arg}");
				}
			}
			if (num > 0)
			{
				Spend(credits + num, cards.Where((DirectorCard card) => card.allowLatePicks), "late");
				foreach (BazaarBase section2 in sections)
				{
					try
					{
						section2.SpawnLatePicks();
					}
					catch (Exception arg2)
					{
						Log.LogError($"Could not spawn the late picks of {section2.GetType().Name}: {arg2}");
					}
				}
			}
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
	public class BazaarDonate : BazaarBase
	{
		private AsyncOperationHandle<GameObject> altarPrefab;

		private AsyncOperationHandle<GameObject> LevelUpEffect;

		private AsyncOperationHandle<GameObject> MoneyPackPickupEffect;

		private AsyncOperationHandle<GameObject> TeamWarCryActivation;

		private AsyncOperationHandle<GameObject> ShrineUseEffect;

		private readonly Dictionary<PlayerCharacterMasterController, int> donationsDuringRun = new Dictionary<PlayerCharacterMasterController, int>();

		private DirectorCard card;

		private bool spawned;

		private GameObject altar;

		private static readonly Vector3 AltarSignOffset = new Vector3(1.5534f, 1.1769f, -0.1835f);

		private static readonly Quaternion AltarSignRotation = Quaternion.Euler(0f, 270f, 0f);

		private readonly ManualLogSource rewardLog = new ManualLogSource("BazaarIsMyHaven");

		private readonly HashSet<string> loggedRewardWarnings = new HashSet<string>();

		public BazaarDonate()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			rewardLog.LogEvent += delegate(object sender, LogEventArgs args)
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				string text = args.Data?.ToString();
				if (text != null && loggedRewardWarnings.Add(text))
				{
					Log.GetSource().Log(args.Level, (object)text);
				}
			};
		}

		public override void Preload()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			altarPrefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/DeepVoidPortalBattery/DeepVoidPortalBattery.prefab");
			LevelUpEffect = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/VFX/LevelUpEffect.prefab");
			MoneyPackPickupEffect = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/BonusGoldPackOnKill/MoneyPackPickupEffect.prefab");
			TeamWarCryActivation = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/TeamWarCry/TeamWarCryActivation.prefab");
			ShrineUseEffect = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/VFX/ShrineUseEffect.prefab");
			DonationRewardDisplay.Preload();
			PriceSigns.Preload();
		}

		public override void Hook()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			PurchaseInteraction.OnInteractionBegin += new hook_OnInteractionBegin(PurchaseInteraction_OnInteractionBegin);
		}

		public override void RunStart()
		{
			donationsDuringRun.Clear();
			loggedRewardWarnings.Clear();
		}

		public override void RunEnd()
		{
			donationsDuringRun.Clear();
		}

		public override void AddDirectorCards(List<DirectorCard> cards)
		{
			card = null;
			if (ModConfig.DonateSectionEnabled.Value)
			{
				card = new DirectorCard("Donation Altar", ModConfig.DonateDirectorCost, ModConfig.DonateDirectorWeight, () => 1);
				cards.Add(card);
			}
		}

		public override void SetupBazaar()
		{
			spawned = false;
			altar = null;
			SpawnLatePicks();
		}

		public override void SpawnLatePicks()
		{
			if (card != null && card.Count != 0 && !spawned)
			{
				SpawnDonateAltar();
				spawned = true;
			}
		}

		private void PurchaseInteraction_OnInteractionBegin(orig_OnInteractionBegin orig, PurchaseInteraction self, Interactor activator)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.EnableMod.Value && ModConfig.DonateSectionEnabled.Value && IsCurrentMapInBazaar() && NetworkServer.active && Object.op_Implicit((Object)(object)altar) && (Object)(object)((Component)self).gameObject == (Object)(object)altar)
			{
				CharacterBody val = (Object.op_Implicit((Object)(object)activator) ? ((Component)activator).GetComponent<CharacterBody>() : null);
				if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val.master) || !Object.op_Implicit((Object)(object)val.inventory))
				{
					return;
				}
				PlayerCharacterMasterController playerCharacterMasterController = val.master.playerCharacterMasterController;
				if (!Object.op_Implicit((Object)(object)playerCharacterMasterController) || !self.available || self.cost < 0 || !self.CanBeAffordedByInteractor(activator))
				{
					return;
				}
				PlayerStruct playerStruct = Main.instance.GetPlayerStruct(playerCharacterMasterController);
				if (CanGetReward(playerCharacterMasterController) && TryGetReward(val.bodyIndex, donationsDuringRun.GetValueOrDefault(playerCharacterMasterController), out var resolvedItems, out var tier))
				{
					Helper.PayCost(self.costType, self.cost, activator, val, ((Component)self).gameObject, self.rng);
					Helper.GivePickups(val, resolvedItems, ((Component)self).transform.position + Vector3.up * 6f, dropReplacedEquipmentsAsPickupDroplets: false);
					playerStruct.RewardCount++;
					donationsDuringRun[playerCharacterMasterController] = donationsDuringRun.GetValueOrDefault(playerCharacterMasterController) + 1;
					ShowRewardEffects(self, val, resolvedItems, tier);
					BazaarBase.SpawnEffect(ShrineUseEffect, ((Component)self).transform.position, new Color32((byte)64, (byte)127, byte.MaxValue, byte.MaxValue), 5f);
					DonationRewardDisplay component = ((Component)self).GetComponent<DonationRewardDisplay>();
					if (Object.op_Implicit((Object)(object)component))
					{
						component.ShowNextReward(playerCharacterMasterController);
					}
					if (!CanGetReward(playerCharacterMasterController))
					{
						DisableFor(playerCharacterMasterController);
					}
				}
			}
			else
			{
				orig.Invoke(self, activator);
			}
		}

		private void DisableFor(PlayerCharacterMasterController pc)
		{
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			if (Object.op_Implicit((Object)(object)altar) && altar.TryGetComponent<InstancedPurchase>(ref instancedPurchase))
			{
				InstancedPurchaseStruct orCreate = instancedPurchase.GetOrCreate(pc);
				if (orCreate.available)
				{
					orCreate.available = false;
					InstancedPurchases.UpdatePlayer(altar, pc);
					PriceSigns.HideFor(altar, pc);
				}
			}
		}

		private bool CanGetReward(PlayerCharacterMasterController pc)
		{
			if (Main.instance.GetPlayerStruct(pc).RewardCount < ModConfig.DonateRewardLimitPerVisit.Value)
			{
				return donationsDuringRun.GetValueOrDefault(pc) < ModConfig.DonateRewardLimitPerRun.Value;
			}
			return false;
		}

		private Dictionary<PickupIndex, int> RollReward(PlayerCharacterMasterController pc)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			CharacterMaster master = pc.master;
			if (!Object.op_Implicit((Object)(object)master) || !CanGetReward(pc))
			{
				return null;
			}
			CharacterBody body = master.GetBody();
			BodyIndex bodyIndex = (BodyIndex)((!Object.op_Implicit((Object)(object)body)) ? ((!Object.op_Implicit((Object)(object)master.bodyPrefab)) ? (-1) : ((int)BodyCatalog.FindBodyIndex(master.bodyPrefab))) : ((int)body.bodyIndex));
			if (!TryGetReward(bodyIndex, donationsDuringRun.GetValueOrDefault(pc), out var resolvedItems, out var _))
			{
				return null;
			}
			return resolvedItems;
		}

		private bool TryGetReward(BodyIndex bodyIndex, int donations, out Dictionary<PickupIndex, int> resolvedItems, out int tier)
		{
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			tier = 0;
			resolvedItems = new Dictionary<PickupIndex, int>();
			List<(float, int)> list = new List<(float, int)>
			{
				(ModConfig.DonateRewardList1Weight.Value, 1),
				(ModConfig.DonateRewardList2Weight.Value, 2),
				(ModConfig.DonateRewardList3Weight.Value, 3),
				(ModConfig.DonateRewardListCharacterWeight.Value, 4)
			};
			list.RemoveAll(((float weight, int tier) item) => item.weight <= 0f);
			if (list.Count == 0)
			{
				rewardLog.LogWarning((object)"No donation lists with a valid weight; the Donation Altar gives no rewards.");
				return false;
			}
			if (ModConfig.DonateSequentialRewardLists.Value)
			{
				list.Sort(((float weight, int tier) a, (float weight, int tier) b) => b.weight.CompareTo(a.weight));
				tier = list[donations % list.Count].Item2;
			}
			else
			{
				double num = RNG.NextDouble() * (double)list.Sum<(float, int)>(((float weight, int tier) item) => item.weight);
				tier = list[list.Count - 1].Item2;
				foreach (var item in list)
				{
					if (num < (double)item.Item1)
					{
						tier = item.Item2;
						break;
					}
					num -= (double)item.Item1;
				}
			}
			switch (tier)
			{
			case 1:
				ParseRewards(ModConfig.DonateRewardList1.Value, resolvedItems);
				break;
			case 2:
				ParseRewards(ModConfig.DonateRewardList2.Value, resolvedItems);
				break;
			case 3:
				ParseRewards(ModConfig.DonateRewardList3.Value, resolvedItems);
				break;
			case 4:
			{
				if (!ModConfig.DonateRewardListCharacters.TryGetValue(bodyIndex, out var value) || !ParseRewards(value.Value, resolvedItems))
				{
					ParseRewards(ModConfig.DonateRewardListCharacterDefault.Value, resolvedItems);
				}
				break;
			}
			}
			if (resolvedItems.Count == 0)
			{
				rewardLog.LogWarning((object)"A donation list has no valid rewards; donations that choose it charge no coins.");
				return false;
			}
			return true;
		}

		private bool ParseRewards(string rewardList, Dictionary<PickupIndex, int> resolvedItems)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Invalid comparison between Unknown and I4
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Invalid comparison between Unknown and I4
			resolvedItems.Clear();
			ItemStringParser.ParseItemString(rewardList, resolvedItems, rewardLog, false, -1);
			KeyValuePair<PickupIndex, int>[] array = resolvedItems.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<PickupIndex, int> keyValuePair = array[i];
				PickupDef pickupDef = PickupCatalog.GetPickupDef(keyValuePair.Key);
				if (keyValuePair.Value <= 0 || pickupDef == null || ((int)pickupDef.itemIndex == -1 && (int)pickupDef.equipmentIndex == -1))
				{
					resolvedItems.Remove(keyValuePair.Key);
				}
			}
			return resolvedItems.Count > 0;
		}

		private void ShowRewardEffects(PurchaseInteraction self, CharacterBody characterBody, Dictionary<PickupIndex, int> resolvedItems, int tier)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			ChatHelper.DonationThanks(characterBody, resolvedItems, tier);
			BazaarBase.SpawnEffect(LevelUpEffect, ((Component)self).transform.position, new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue), 3f);
			BazaarBase.SpawnEffect(MoneyPackPickupEffect, ((Component)self).transform.position, new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue), 3f);
			BazaarBase.SpawnEffect(TeamWarCryActivation, ((Component)self).transform.position, new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue), 3f);
		}

		private void SpawnDonateAltar()
		{
			//IL_001b: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			altar = Object.Instantiate<GameObject>(altarPrefab.WaitForCompletion(), new Vector3(-114.4226f, -22.6017f, -49.9827f), Quaternion.Euler(0f, 300f, 0f));
			PurchaseInteraction component = altar.GetComponent<PurchaseInteraction>();
			int cost = (component.Networkcost = (component.cost = Helper.GetCost(ModConfig.DonateCost.Value, ModConfig.DonateCostType.Value)));
			component.NetworkcostType = ModConfig.DonateCostType.Value;
			component.NetworkdisplayNameToken = "NEWT_STATUE_NAME";
			component.NetworkcontextToken = "NEWT_STATUE_CONTEXT";
			DonationRewardDisplay.Apply(altar, RollReward);
			altar.AddComponent<InstancedPurchase>().original.available = true;
			NetworkServer.Spawn(altar);
			VoidSignalBeam.Remove(altar);
			PriceSigns.Apply(altar, altar.transform.TransformPoint(AltarSignOffset), altar.transform.rotation * AltarSignRotation, cost, ModConfig.DonateCostType.Value);
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				if (Object.op_Implicit((Object)(object)instance) && !CanGetReward(instance))
				{
					DisableFor(instance);
				}
			}
		}
	}
	public class BazaarDrones : BazaarBase
	{
		private class Station
		{
			public DirectorCard card;

			public AsyncOperationHandle<GameObject> prefab;

			public SpawnCardStruct slot;

			public bool spawned;

			public GameObject instance;
		}

		private AsyncOperationHandle<GameObject> DroneCombinerStation;

		private AsyncOperationHandle<GameObject> DroneUpgradeStation;

		private AsyncOperationHandle<GameObject> DroneScrapper;

		private AsyncOperationHandle<GameObject> TripleDroneShop;

		private readonly List<Station> stations = new List<Station>();

		private Station upgradeStation;

		private Station tripleDroneShop;

		public override void Preload()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			DroneCombinerStation = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC3/DroneCombinerStation/DroneCombinerStation.prefab");
			DroneUpgradeStation = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC3/DroneAssemblyStation/DroneAssemblyStation.prefab");
			DroneScrapper = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC3/DroneScrapper/DroneScrapper.prefab");
			TripleDroneShop = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC3/TripleDroneShop/TripleDroneShop.prefab");
			PriceSigns.Preload();
		}

		public override void Hook()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			Stage.RespawnAllNPCs += new hook_RespawnAllNPCs(Stage_RespawnAllNPCs);
			PickupPickerController.GetInteractability += new hook_GetInteractability(PickupPickerController_GetInteractability);
			PurchaseInteraction.GetInteractability += new hook_GetInteractability(PurchaseInteraction_GetInteractability);
			DroneVendorMultiShopController.Start += new hook_Start(DroneVendorMultiShopController_Start);
			DroneVendorMultiShopController.ResetDroneVendor += new hook_ResetDroneVendor(DroneVendorMultiShopController_ResetDroneVendor);
		}

		private static bool IsSectionActive()
		{
			if (ModConfig.DronesSectionEnabled.Value && Object.op_Implicit((Object)(object)DLC3Content.DLC3) && Object.op_Implicit((Object)(object)Run.instance))
			{
				return Run.instance.IsExpansionEnabled(DLC3Content.DLC3);
			}
			return false;
		}

		public override void AddDirectorCards(List<DirectorCard> cards)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			stations.Clear();
			upgradeStation = null;
			tripleDroneShop = null;
			if (IsSectionActive())
			{
				AddStation(cards, "Drone Combiner Station", ModConfig.DronesDroneCombinerStationDirectorCost, ModConfig.DronesDroneCombinerStationDirectorWeight, DroneCombinerStation, new SpawnCardStruct(new Vector3(-81.4188f, -23.0829f, -3.7793f), new Vector3(0f, 165f, 350f)));
				upgradeStation = AddStation(cards, "Drone Upgrade Station", ModConfig.DronesDroneUpgradeStationDirectorCost, ModConfig.DronesDroneUpgradeStationDirectorWeight, DroneUpgradeStation, new SpawnCardStruct(new Vector3(-85.1751f, -22.264f, -3.539f), new Vector3(0f, 150f, 270f)));
				AddStation(cards, "Drone Scrapper", ModConfig.DronesDroneScrapperDirectorCost, ModConfig.DronesDroneScrapperDirectorWeight, DroneScrapper, new SpawnCardStruct(new Vector3(-92.3398f, -26.1678f, -51.8777f), new Vector3(0f, 315f, 0f)));
				tripleDroneShop = AddStation(cards, "Triple Drone Shop", ModConfig.DronesTripleDroneShopDirectorCost, ModConfig.DronesTripleDroneShopDirectorWeight, TripleDroneShop, new SpawnCardStruct(new Vector3(-64.3101f, -23.0074f, -19.7406f), new Vector3(0f, 300f, 6f)));
			}
		}

		private Station AddStation(List<DirectorCard> cards, string name, ConfigEntry<int> cost, ConfigEntry<float> weight, AsyncOperationHandle<GameObject> prefab, SpawnCardStruct slot)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			Station station = new Station
			{
				card = new DirectorCard(name, cost, weight, () => 1),
				prefab = prefab,
				slot = slot
			};
			stations.Add(station);
			cards.Add(station.card);
			return station;
		}

		public override void SetupBazaar()
		{
			SpawnLatePicks();
		}

		public override void SpawnLatePicks()
		{
			foreach (Station station in stations)
			{
				if (station.card.Count != 0 && !station.spawned)
				{
					station.instance = BazaarBase.SpawnAt(station.prefab.WaitForCompletion(), station.slot);
					station.spawned = true;
				}
			}
		}

		private void Stage_RespawnAllNPCs(orig_RespawnAllNPCs orig, Stage self)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (!ModConfig.EnableMod.Value || !IsCurrentMapInBazaar() || !IsSectionActive() || !Object.op_Implicit((Object)(object)self.sceneDef) || !self.sceneDef.suppressNpcEntry)
			{
				return;
			}
			Transform playerSpawnTransform = self.GetPlayerSpawnTransform();
			ReadOnlyCollection<CharacterMaster> readOnlyInstancesList = CharacterMaster.readOnlyInstancesList;
			for (int i = 0; i < readOnlyInstancesList.Count; i++)
			{
				CharacterMaster val = readOnlyInstancesList[i];
				if (!IsPlayerDrone(val) || Object.op_Implicit((Object)(object)val.GetBodyObject()) || !Util.IsDontDestroyOnLoad(((Component)val).gameObject))
				{
					continue;
				}
				Vector3 val2 = Vector3.zero;
				Quaternion val3 = Quaternion.identity;
				if (Object.op_Implicit((Object)(object)playerSpawnTransform))
				{
					val2 = playerSpawnTransform.position;
					val3 = playerSpawnTransform.rotation;
					BaseAI component = ((Component)val).GetComponent<BaseAI>();
					CharacterBody component2 = val.bodyPrefab.GetComponent<CharacterBody>();
					NodeGraph val4 = ((Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component2)) ? component.GetDesiredSpawnNodeGraph() : null);
					if (Object.op_Implicit((Object)(object)val4))
					{
						List<NodeIndex> list = new List<NodeIndex>();
						val4.FindNodesInRange(val2, 10f, 100f, (HullMask)(1 << (int)component2.hullClassification), list);
						if (list.Count > 0)
						{
							val4.GetNodePosition(list[Random.Range(0, list.Count)], ref val2);
						}
					}
				}
				val.Respawn(val2, val3, true);
			}
		}

		private void DroneVendorMultiShopController_Start(orig_Start orig, DroneVendorMultiShopController self)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Invalid comparison between Unknown and I4
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active || tripleDroneShop == null || !Object.op_Implicit((Object)(object)tripleDroneShop.instance) || (Object)(object)((Component)self).gameObject != (Object)(object)tripleDroneShop.instance || !Object.op_Implicit((Object)(object)Run.instance))
			{
				orig.Invoke(self);
				return;
			}
			float num = Mathf.Max(0f, ModConfig.DronesTripleDroneShopCommonWeight.Value);
			float num2 = Mathf.Max(0f, ModConfig.DronesTripleDroneShopUncommonWeight.Value);
			if (num + num2 <= 0f)
			{
				num = 1f;
			}
			self.tier1Chance = new RangeFloat
			{
				min = num,
				max = num
			};
			self.tier2Chance = new RangeFloat
			{
				min = num2,
				max = num2
			};
			self.tier3Chance = new RangeFloat
			{
				min = 0f,
				max = 0f
			};
			self.baseCostTier1 = ModConfig.DronesTripleDroneShopCommonCost.Value;
			self.baseCostTier2 = ModConfig.DronesTripleDroneShopUncommonCost.Value;
			CostTypeIndex val = (self.costType = ModConfig.DronesTripleDroneShopCostType.Value);
			Run instance = Run.instance;
			int stageClearCount = instance.stageClearCount;
			instance.stageClearCount = Mathf.Max(stageClearCount, 3);
			try
			{
				orig.Invoke(self);
			}
			finally
			{
				instance.stageClearCount = stageClearCount;
			}
			int num3 = (self.Networkcost = Helper.GetCost(self.baseCost, val));
			DroneVendorTerminalBehavior[] array = (DroneVendorTerminalBehavior[])(((object)self._terminals) ?? ((object)new DroneVendorTerminalBehavior[0]));
			foreach (DroneVendorTerminalBehavior val2 in array)
			{
				if (Object.op_Implicit((Object)(object)val2) && Object.op_Implicit((Object)(object)val2.purchaseInteraction))
				{
					val2.purchaseInteraction.Networkcost = num3;
				}
			}
			if ((int)val != 1)
			{
				HologramProjector component = ((Component)self).GetComponent<HologramProjector>();
				Transform val3 = ((Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component.hologramPivot)) ? component.hologramPivot : ((Component)self).transform);
				self.Networkavailable = false;
				PriceSigns.Apply(((Component)self).gameObject, val3.position, ((Component)self).transform.rotation * Quaternion.Euler(0f, 180f, 0f), num3, val);
			}
		}

		private void DroneVendorMultiShopController_ResetDroneVendor(orig_ResetDroneVendor orig, DroneVendorMultiShopController self)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			orig.Invoke(self);
			if (NetworkServer.active && tripleDroneShop != null && Object.op_Implicit((Object)(object)tripleDroneShop.instance) && (Object)(object)((Component)self).gameObject == (Object)(object)tripleDroneShop.instance && (int)self.costType != 1)
			{
				self.Networkavailable = false;
			}
		}

		private Interactability PickupPickerController_GetInteractability(orig_GetInteractability orig, PickupPickerController self, Interactor activator)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (!RefusesUpgrade(((Component)self).gameObject, activator))
			{
				return orig.Invoke(self, activator);
			}
			return (Interactability)1;
		}

		private Interactability PurchaseInteraction_GetInteractability(orig_GetInteractability orig, PurchaseInteraction self, Interactor activator)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (!RefusesUpgrade(((Component)self).gameObject, activator))
			{
				return orig.Invoke(self, activator);
			}
			return (Interactability)1;
		}

		private bool RefusesUpgrade(GameObject interactable, Interactor activator)
		{
			if (upgradeStation == null || !Object.op_Implicit((Object)(object)upgradeStation.instance) || (Object)(object)interactable != (Object)(object)upgradeStation.instance || !Object.op_Implicit((Object)(object)activator))
			{
				return false;
			}
			CharacterBody component = ((Component)activator).GetComponent<CharacterBody>();
			if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component.master))
			{
				return !HasDrones(component.master);
			}
			return true;
		}

		private static bool HasDrones(CharacterMaster owner)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			MinionGroup val = MinionGroup.FindGroup(((NetworkBehaviour)owner).netId);
			if (val == null)
			{
				return false;
			}
			MinionOwnership[] members = val.members;
			foreach (MinionOwnership val2 in members)
			{
				CharacterMaster val3 = (Object.op_Implicit((Object)(object)val2) ? ((Component)val2).GetComponent<CharacterMaster>() : null);
				CharacterBody val4 = (Object.op_Implicit((Object)(object)val3) ? val3.GetBody() : null);
				if (Object.op_Implicit((Object)(object)val4) && (val4.bodyFlags & 0x400000) != 0)
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsPlayerDrone(CharacterMaster master)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Invalid comparison between Unknown and I4
			if (!Object.op_Implicit((Object)(object)master) || !Object.op_Implicit((Object)(object)master.bodyPrefab) || !Object.op_Implicit((Object)(object)master.minionOwnership))
			{
				return false;
			}
			CharacterMaster ownerMaster = master.minionOwnership.ownerMaster;
			CharacterBody val = default(CharacterBody);
			if (Object.op_Implicit((Object)(object)ownerMaster) && Object.op_Implicit((Object)(object)ownerMaster.playerCharacterMasterController) && master.bodyPrefab.TryGetComponent<CharacterBody>(ref val))
			{
				return (val.bodyFlags & 0x400000) > 0;
			}
			return false;
		}
	}
	public class BazaarEquipment : BazaarBase
	{
		private AsyncOperationHandle<GameObject> multiShopEquipmentTerminal;

		private Dictionary<int, SpawnCardStruct> DicEquipments = new Dictionary<int, SpawnCardStruct>();

		private DirectorCard card;

		private int spawned;

		private PlayerCharacterMasterController currentActivator;

		public override void Preload()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			multiShopEquipmentTerminal = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/MultiShopEquipmentTerminal/MultiShopEquipmentTerminal.prefab");
			PriceSigns.Preload();
		}

		public override void Hook()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			PurchaseInteraction.Awake += new hook_Awake(PurchaseInteraction_Awake);
			PurchaseInteraction.OnInteractionBegin += new hook_OnInteractionBegin(PurchaseInteraction_OnInteractionBegin);
			ShopTerminalBehavior.DropPickup += new hook_DropPickup(ShopTerminalBehavior_DropPickup);
			ShopTerminalBehavior.GenerateNewPickupServer_bool += new hook_GenerateNewPickupServer_bool(ShopTerminalBehavior_GenerateNewPickupServer_bool);
		}

		public override void RunStart()
		{
		}

		public override void AddDirectorCards(List<DirectorCard> cards)
		{
			card = null;
			if (ModConfig.EquipmentSectionEnabled.Value)
			{
				card = new DirectorCard("Equipment Terminal", ModConfig.EquipmentDirectorCost, ModConfig.EquipmentDirectorWeight, GetMaxTerminals);
				cards.Add(card);
			}
		}

		public override void SetupBazaar()
		{
			if (card != null)
			{
				DicEquipments.Clear();
				SetEquipment();
				spawned = 0;
				SpawnLatePicks();
			}
		}

		private static int GetMaxTerminals()
		{
			return Math.Min(ModConfig.EquipmentMaxAmount.Value, ModConfig.EquipmentReplaceLunarSeersWithEquipment.Value ? 5 : 3);
		}

		public void PurchaseInteraction_Awake(orig_Awake orig, PurchaseInteraction self)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (ModConfig.EnableMod.Value && ModConfig.EquipmentSectionEnabled.Value && IsCurrentMapInBazaar() && NetworkServer.active && ModConfig.EquipmentMaxAmount.Value > 0 && ((Object)self).name.StartsWith("MultiShopEquipmentTerminal"))
			{
				self.Networkcost = (self.cost = Helper.GetCost(ModConfig.EquipmentCost.Value, ModConfig.EquipmentCostType.Value));
				self.NetworkcostType = ModConfig.EquipmentCostType.Value;
			}
		}

		private void PurchaseInteraction_OnInteractionBegin(orig_OnInteractionBegin orig, PurchaseInteraction self, Interactor activator)
		{
			if (ModConfig.EnableMod.Value && ModConfig.EquipmentSectionEnabled.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("MultiShopEquipmentTerminal"))
			{
				CharacterBody val = (Object.op_Implicit((Object)(object)activator) ? ((Component)activator).GetComponent<CharacterBody>() : null);
				PlayerCharacterMasterController player = ((Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.master)) ? val.master.playerCharacterMasterController : null);
				PlayerCharacterMasterController val2 = currentActivator;
				try
				{
					currentActivator = player;
					if (FreeSwaps.IsFreeFor((Component)(object)self, player))
					{
						FreeSwaps.RunFree(self, delegate
						{
							orig.Invoke(self, activator);
							return true;
						});
					}
					else
					{
						orig.Invoke(self, activator);
					}
					return;
				}
				finally
				{
					currentActivator = val2;
				}
			}
			orig.Invoke(self, activator);
		}

		private void ShopTerminalBehavior_DropPickup(orig_DropPickup orig, ShopTerminalBehavior self)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.EnableMod.Value && ModConfig.EquipmentSectionEnabled.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("MultiShopEquipmentTerminal"))
			{
				if (ModConfig.EquipmentBuyToInventory.Value)
				{
					CharacterBody val = ((Object.op_Implicit((Object)(object)currentActivator) && Object.op_Implicit((Object)(object)currentActivator.master)) ? currentActivator.master.GetBody() : null);
					if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val.inventory))
					{
						orig.Invoke(self);
						return;
					}
					EquipmentIndex val2 = Helper.GivePickup(val, self.CurrentPickup().pickupIndex, ((Component)self).transform.position, dropReplacedEquipmentAsPickupDroplet: false);
					if ((int)val2 != -1)
					{
						Helper.CreateItemTakenOrb(val.corePosition, ((Component)self).gameObject, PickupCatalog.FindPickupIndex(val2));
						self.SetPickup(new UniquePickup(PickupCatalog.FindPickupIndex(val2)), false);
						((Component)self).GetComponent<PurchaseInteraction>().SetAvailable(true);
						bool num = !FreeSwaps.IsFreeFor((Component)(object)self, currentActivator);
						FreeSwaps.BuySlot(((Component)self).gameObject, currentActivator);
						PriceSigns.HideFor(((Component)self).gameObject, currentActivator);
						if (num)
						{
							InstancedPurchases.PlayBuySound(self, currentActivator);
						}
					}
					else
					{
						self.SetHasBeenPurchased(true);
						self.SetNoPickup();
					}
				}
				else
				{
					orig.Invoke(self);
					self.SetNoPickup();
				}
			}
			else
			{
				orig.Invoke(self);
			}
		}

		private void ShopTerminalBehavior_GenerateNewPickupServer_bool(orig_GenerateNewPickupServer_bool orig, ShopTerminalBehavior self, bool newHidden)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.EnableMod.Value && ModConfig.EquipmentSectionEnabled.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("MultiShopEquipmentTerminal") && Run.instance.stageRng.nextNormalizedFloat < ModConfig.EquipmentReplaceWithEliteChance.Value)
			{
				Dictionary<PickupIndex, int> dictionary = new Dictionary<PickupIndex, int>();
				ItemStringParser.ParseItemString(ModConfig.EquipmentReplaceWithEliteList.Value, dictionary, Log.GetSource(), false, -1);
				bool flag = false;
				foreach (var (val2, num2) in dictionary)
				{
					if (num2 > 0)
					{
						self.SetPickup(new UniquePickup(val2), newHidden);
						flag = true;
						return;
					}
				}
				if (!flag)
				{
					Log.LogError("Could not get a proper pickup index from EquipmentReplaceWithEliteList: " + ModConfig.EquipmentReplaceWithEliteList.Value);
				}
			}
			orig.Invoke(self, newHidden);
		}

		private void SetEquipment()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = new List<int> { 0, 1, 2 };
			if (ModConfig.EquipmentReplaceLunarSeersWithEquipment.Value)
			{
				list = new List<int> { 2, 3, 4 };
				DicEquipments.Add(0, new SpawnCardStruct(new Vector3(-133.9731f, -23.4f, -10.71112f), new Vector3(0f, 120f, 0f)));
				DicEquipments.Add(1, new SpawnCardStruct(new Vector3(-128.0793f, -23.4f, -7.056283f), new Vector3(0f, 160f, 0f)));
			}
			List<int> list2 = new List<int>();
			while (list.Count > 0)
			{
				int index = RNG.Next(list.Count);
				list2.Add(list[index]);
				list.RemoveAt(index);
			}
			DicEquipments.Add(list2[0], new SpawnCardStruct(new Vector3(-139.5818f, -23.561f, -1.7491f), new Vector3(0f, 175f, 0f)));
			DicEquipments.Add(list2[1], new SpawnCardStruct(new Vector3(-136.5639f, -23.7163f, -0.5618f), new Vector3(0f, 145f, 0f)));
			DicEquipments.Add(list2[2], new SpawnCardStruct(new Vector3(-134.82f, -23.36f, 1.85f), new Vector3(0f, 105f, 0f)));
		}

		public override void SpawnLatePicks()
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			if (card == null || card.Count <= spawned)
			{
				return;
			}
			List<GameObject> list = BazaarBase.SpawnInSlots(DicEquipments, multiShopEquipmentTerminal.WaitForCompletion(), spawned, card.Count - spawned);
			spawned = card.Count;
			list.ForEach(delegate(GameObject gameObject)
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				PurchaseInteraction component = gameObject.GetComponent<PurchaseInteraction>();
				ShopTerminalBehavior component2 = gameObject.GetComponent<ShopTerminalBehavior>();
				if (ModConfig.EquipmentInstancedPurchases.Value)
				{
					InstancedPurchase instancedPurchase = gameObject.AddComponent<InstancedPurchase>();
					instancedPurchase.original.available = component.available;
					instancedPurchase.original.pickup = component2.pickup;
					instancedPurchase.original.hasBeenPurchased = component2.hasBeenPurchased;
				}
			});
			PriceSigns.Apply(list, Helper.GetCost(ModConfig.EquipmentCost.Value, ModConfig.EquipmentCostType.Value), ModConfig.EquipmentCostType.Value, 5.25f);
		}
	}
	public class BazaarLunarShop : BazaarBase
	{
		private const string LunarShopObjectName = "LunarShopTerminal_BazaarIsMyHaven";

		private AsyncOperationHandle<GameObject> lunarShopBud;

		private AsyncOperationHandle<GameObject> LunarRerollEffect;

		private Dictionary<int, SpawnCardStruct> DicLunarShopTerminals = new Dictionary<int, SpawnCardStruct>();

		private int generateNewPickupIndex;

		private int lunarRecyclerRerolledCount;

		private List<GameObject> ObjectLunarShopTerminals_Spawn = new List<GameObject>();

		private DirectorCard card;

		private PlayerCharacterMasterController currentActivator;

		private Dictionary<PurchaseInteraction, List<PlayerCharacterMasterController>> whichStallsHaveBeenBoughtOnce = new Dictionary<PurchaseInteraction, List<PlayerCharacterMasterController>>();

		public override void Preload()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			lunarShopBud = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/LunarShopTerminal/LunarShopTerminal.prefab");
			LunarRerollEffect = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/LunarRecycler/LunarRerollEffect.prefab");
			LunarBudScaleSync.Preload();
		}

		public override void Hook()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			PurchaseInteraction.Awake += new hook_Awake(PurchaseInteraction_Awake);
			PurchaseInteraction.OnInteractionBegin += new hook_OnInteractionBegin(PurchaseInteraction_OnInteractionBegin);
			PurchaseInteraction.ScaleCost += new hook_ScaleCost(PurchaseInteraction_ScaleCost);
			PurchaseInteraction.SetAvailable += new hook_SetAvailable(PurchaseInteraction_SetAvailable);
			ShopTerminalBehavior.DropPickup += new hook_DropPickup(ShopTerminalBehavior_DropPickup);
			ShopTerminalBehavior.GenerateNewPickupServer_bool += new hook_GenerateNewPickupServer_bool(ShopTerminalBehavior_GenerateNewPickupServer_bool);
			SceneManager.sceneUnloaded += SceneUnloaded;
		}

		public override void RunStart()
		{
			RunEnd();
		}

		public override void RunEnd()
		{
			ObjectLunarShopTerminals_Spawn.Clear();
			whichStallsHaveBeenBoughtOnce.Clear();
			currentActivator = null;
		}

		private void SceneUnloaded(Scene scene)
		{
			if (((Scene)(ref scene)).name == "bazaar")
			{
				RunEnd();
			}
		}

		public override void AddDirectorCards(List<DirectorCard> cards)
		{
			card = null;
			if (ModConfig.LunarShopSectionEnabled.Value)
			{
				card = new DirectorCard("Lunar Bud", ModConfig.LunarShopDirectorCost, ModConfig.LunarShopDirectorWeight, () => ModConfig.LunarShopMaxAmount.Value, null, allowLatePicks: false);
				cards.Add(card);
			}
		}

		public override void SetupBazaar()
		{
			lunarRecyclerRerolledCount = 0;
			if (card != null)
			{
				generateNewPickupIndex = 0;
				whichStallsHaveBeenBoughtOnce.Clear();
				SpawnLunarShopTerminal();
			}
			RemoveLunarRecycler();
		}

		private void RemoveLunarRecycler()
		{
			bool num = ModConfig.LunarRecyclerSectionEnabled.Value && (!ModConfig.LunarRecyclerAvailable.Value || ModConfig.LunarRecyclerCost.Value < 0);
			bool flag = card != null && card.Count == 0;
			if (!num && !flag)
			{
				return;
			}
			PurchaseInteraction[] array = Object.FindObjectsOfType<PurchaseInteraction>();
			foreach (PurchaseInteraction val in array)
			{
				if (((Object)val).name.StartsWith("LunarRecycler"))
				{
					NetworkServer.Destroy(((Component)val).gameObject);
				}
			}
		}

		public void PurchaseInteraction_Awake(orig_Awake orig, PurchaseInteraction self)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (!ModConfig.EnableMod.Value || !IsCurrentMapInBazaar() || !NetworkServer.active)
			{
				return;
			}
			if (ModConfig.LunarShopSectionEnabled.Value && ((Object)self).name.StartsWith("LunarShopTerminal"))
			{
				self.NetworkcostType = ModConfig.LunarShopCostType.Value;
				if (ModConfig.LunarShopCost.Value >= 0)
				{
					self.Networkcost = (self.cost = Helper.GetCost(ModConfig.LunarShopCost.Value, ModConfig.LunarShopCostType.Value));
				}
			}
			if (ModConfig.LunarRecyclerSectionEnabled.Value && ModConfig.LunarRecyclerAvailable.Value && ModConfig.LunarRecyclerCost.Value >= 0 && ((Object)self).name.StartsWith("LunarRecycler"))
			{
				self.cost = ModConfig.LunarRecyclerCost.Value;
				self.Networkcost = ModConfig.LunarRecyclerCost.Value;
			}
		}

		private bool TryCompletePurchase(orig_OnInteractionBegin orig, PurchaseInteraction self, Interactor activator, PlayerCharacterMasterController player)
		{
			bool purchaseSucceeded = false;
			UnityAction<PayCostContext, PayCostResults> val = delegate(PayCostContext context, PayCostResults results)
			{
				if ((Object)(object)context.activator == (Object)(object)activator)
				{
					purchaseSucceeded = true;
				}
			};
			PlayerCharacterMasterController val2 = currentActivator;
			((UnityEvent<PayCostContext, PayCostResults>)(object)self.onDetailedPurchaseServer).AddListener(val);
			try
			{
				currentActivator = player;
				orig.Invoke(self, activator);
			}
			finally
			{
				currentActivator = val2;
				((UnityEvent<PayCostContext, PayCostResults>)(object)self.onDetailedPurchaseServer).RemoveListener(val);
			}
			return purchaseSucceeded;
		}

		public void PurchaseInteraction_OnInteractionBegin(orig_OnInteractionBegin orig, PurchaseInteraction self, Interactor activator)
		{
			if (ModConfig.EnableMod.Value && IsCurrentMapInBazaar() && NetworkServer.active && (ModConfig.LunarShopSectionEnabled.Value || ModConfig.LunarRecyclerSectionEnabled.Value))
			{
				CharacterBody val = (Object.op_Implicit((Object)(object)activator) ? ((Component)activator).GetComponent<CharacterBody>() : null);
				PlayerCharacterMasterController player = ((Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.master)) ? val.master.playerCharacterMasterController : null);
				if (!Object.op_Implicit((Object)(object)player))
				{
					orig.Invoke(self, activator);
					return;
				}
				if (ModConfig.LunarShopSectionEnabled.Value && whichStallsHaveBeenBoughtOnce.TryGetValue(self, out var value))
				{
					PlayerStruct playerStruct = Main.instance.GetPlayerStruct(player);
					bool flag = !value.Contains(player);
					int num = ModConfig.LunarShopBuyLimit.Value - playerStruct.LunarShopUseCount;
					if (flag && ModConfig.LunarShopBuyLimit.Value >= 0 && num <= 0)
					{
						ChatHelper.LunarShopTerminalUsesLeft(player, num);
					}
					else if ((FreeSwaps.IsFreeFor((Component)(object)self, player) ? FreeSwaps.RunFree(self, () => TryCompletePurchase(orig, self, activator, player)) : TryCompletePurchase(orig, self, activator, player)) && flag)
					{
						value.Add(player);
						playerStruct.LunarShopUseCount++;
						ChatHelper.LunarPurchase();
						InstancedPurchase instancedPurchase = default(InstancedPurchase);
						if (((Component)self).TryGetComponent<InstancedPurchase>(ref instancedPurchase))
						{
							instancedPurchase.GetOrCreate(player).hasBeenPurchasedOnce = true;
						}
						if (ModConfig.LunarShopBuyLimit.Value >= 0)
						{
							ChatHelper.LunarShopTerminalUsesLeft(player, ModConfig.LunarShopBuyLimit.Value - playerStruct.LunarShopUseCount);
						}
					}
					return;
				}
				if (((Object)self).name.StartsWith("LunarRecycler"))
				{
					if (!self.available || (ModConfig.LunarRecyclerSectionEnabled.Value && ModConfig.LunarRecyclerRerollLimit.Value >= 0 && lunarRecyclerRerolledCount >= ModConfig.LunarRecyclerRerollLimit.Value) || !TryCompletePurchase(orig, self, activator, player))
					{
						return;
					}
					if (ModConfig.LunarRecyclerSectionEnabled.Value)
					{
						lunarRecyclerRerolledCount++;
						if (ModConfig.LunarRecyclerRerollLimit.Value >= 0)
						{
							int num2 = ModConfig.LunarRecyclerRerollLimit.Value - lunarRecyclerRerolledCount;
							ChatHelper.LunarRecyclerUsesLeft(num2);
							if (num2 <= 0)
							{
								self.SetAvailable(false);
							}
						}
					}
					if (!ModConfig.LunarShopSectionEnabled.Value)
					{
						return;
					}
					float num3 = 0f;
					{
						foreach (GameObject item in ObjectLunarShopTerminals_Spawn)
						{
							((MonoBehaviour)Main.instance).StartCoroutine(DelayRerollEffect(item, num3));
							num3 += 0.1f;
						}
						return;
					}
				}
			}
			orig.Invoke(self, activator);
		}

		private void PurchaseInteraction_ScaleCost(orig_ScaleCost orig, PurchaseInteraction self, float scalar)
		{
			if (ModConfig.EnableMod.Value && ModConfig.LunarRecyclerSectionEnabled.Value && ModConfig.LunarRecyclerAvailable.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("LunarRecycler"))
			{
				scalar = ModConfig.LunarRecyclerCostMultiplier.Value;
			}
			orig.Invoke(self, scalar);
		}

		private void PurchaseInteraction_SetAvailable(orig_SetAvailable orig, PurchaseInteraction self, bool newAvailable)
		{
			if (ModConfig.EnableMod.Value && ModConfig.LunarRecyclerSectionEnabled.Value && ModConfig.LunarRecyclerAvailable.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("LunarRecycler") && ModConfig.LunarRecyclerRerollLimit.Value >= 0)
			{
				newAvailable = newAvailable && lunarRecyclerRerolledCount < ModConfig.LunarRecyclerRerollLimit.Value;
			}
			orig.Invoke(self, newAvailable);
		}

		private void ShopTerminalBehavior_DropPickup(orig_DropPickup orig, ShopTerminalBehavior self)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Invalid comparison between Unknown and I4
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.EnableMod.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("LunarShopTerminal"))
			{
				if (!ModConfig.LunarShopSectionEnabled.Value)
				{
					orig.Invoke(self);
					SendPurchasedFlagToClients(self);
				}
				else if (ModConfig.LunarShopBuyToInventory.Value)
				{
					CharacterBody val = ((Object.op_Implicit((Object)(object)currentActivator) && Object.op_Implicit((Object)(object)currentActivator.master)) ? currentActivator.master.GetBody() : null);
					if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val.inventory))
					{
						orig.Invoke(self);
						SendPurchasedFlagToClients(self);
						self.SetNoPickup();
						return;
					}
					EquipmentIndex val2 = Helper.GivePickup(val, self.CurrentPickup().pickupIndex, ((Component)self).transform.position, dropReplacedEquipmentAsPickupDroplet: false);
					if ((int)val2 != -1)
					{
						Helper.CreateItemTakenOrb(val.corePosition, ((Component)self).gameObject, PickupCatalog.FindPickupIndex(val2));
						self.SetPickup(new UniquePickup(PickupCatalog.FindPickupIndex(val2)), false);
						((Component)self).GetComponent<PurchaseInteraction>().SetAvailable(true);
						bool num = !FreeSwaps.IsFreeFor((Component)(object)self, currentActivator);
						FreeSwaps.BuySlot(((Component)self).gameObject, currentActivator);
						if (num)
						{
							InstancedPurchases.PlayBuySound(self, currentActivator);
						}
					}
					else
					{
						self.SetHasBeenPurchased(true);
						SendPurchasedFlagToClients(self);
						self.SetNoPickup();
					}
				}
				else
				{
					orig.Invoke(self);
					SendPurchasedFlagToClients(self);
					self.SetNoPickup();
				}
			}
			else
			{
				orig.Invoke(self);
			}
		}

		private void ShopTerminalBehavior_GenerateNewPickupServer_bool(orig_GenerateNewPickupServer_bool orig, ShopTerminalBehavior self, bool newHidden)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.EnableMod.Value && ModConfig.LunarShopSectionEnabled.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("LunarShopTerminal"))
			{
				if (TryGenerateLunarShopPickup(out var pickup))
				{
					self.SetPickup(pickup, newHidden);
				}
			}
			else
			{
				orig.Invoke(self, newHidden);
			}
		}

		private void SendPurchasedFlagToClients(ShopTerminalBehavior shop)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active || Object.op_Implicit((Object)(object)((Component)shop).GetComponent<InstancedPurchase>()) || !shop.hasBeenPurchased)
			{
				return;
			}
			NetworkIdentity component = ((Component)shop).GetComponent<NetworkIdentity>();
			if (!Object.op_Implicit((Object)(object)component) || component.observers == null)
			{
				return;
			}
			int networkChannel = ((NetworkBehaviour)shop).GetNetworkChannel();
			NetworkWriter val = new NetworkWriter();
			val.StartMessage((short)8);
			val.Write(component.netId);
			NetworkBehaviour[] behavioursOfSameChannel = component.GetBehavioursOfSameChannel(networkChannel, false);
			foreach (NetworkBehaviour val2 in behavioursOfSameChannel)
			{
				uint syncVarDirtyBits = val2.m_SyncVarDirtyBits;
				try
				{
					val2.m_SyncVarDirtyBits = (((Object)(object)val2 == (Object)(object)shop) ? 4u : 0u);
					val2.OnSerialize(val, false);
				}
				finally
				{
					val2.m_SyncVarDirtyBits = syncVarDirtyBits;
				}
			}
			val.FinishMessage();
			foreach (NetworkConnection observer in component.observers)
			{
				if (observer.isReady && !Util.ConnectionIsLocal(observer) && !observer.SendWriter(val, networkChannel))
				{
					Log.LogWarning("Could not send the bud purchased flag.");
				}
			}
		}

		private bool TryGenerateLunarShopPickup(out UniquePickup pickup)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			int num = (ModConfig.LunarShopSequentialItems.Value ? generateNewPickupIndex : (-1));
			Dictionary<PickupIndex, int> dictionary = new Dictionary<PickupIndex, int>();
			ItemStringParser.ParseItemString(ModConfig.LunarShopItemList.Value, dictionary, Log.GetSource(), false, num);
			foreach (var (val2, num3) in dictionary)
			{
				if (num3 > 0 && PickupCatalog.GetPickupDef(val2) != null)
				{
					pickup = new UniquePickup(val2);
					generateNewPickupIndex++;
					return true;
				}
			}
			pickup = UniquePickup.none;
			Log.LogError("Could not get a pickup index from LunarShopItemList: " + ModConfig.LunarShopItemList.Value);
			return false;
		}

		private IEnumerator DelayRerollEffect(GameObject shop, float delay)
		{
			yield return (object)new WaitForSeconds(delay);
			if (!NetworkServer.active || !Object.op_Implicit((Object)(object)shop))
			{
				yield break;
			}
			ShopTerminalBehavior component = shop.GetComponent<ShopTerminalBehavior>();
			PurchaseInteraction component2 = shop.GetComponent<PurchaseInteraction>();
			if (!Object.op_Implicit((Object)(object)component) || !Object.op_Implicit((Object)(object)component2))
			{
				yield break;
			}
			InstancedPurchase instance = default(InstancedPurchase);
			if (shop.TryGetComponent<InstancedPurchase>(ref instance))
			{
				if (!PlayerCharacterMasterController.instances.Any((PlayerCharacterMasterController pc) => Object.op_Implicit((Object)(object)pc) && instance.GetOrOriginal(pc).CanReroll) || !TryGenerateLunarShopPickup(out var pickup))
				{
					yield break;
				}
				if (instance.original.CanReroll)
				{
					instance.original.pickup = pickup;
					instance.original.hidden = false;
				}
				foreach (InstancedPurchaseStruct value2 in instance.purchases.Values)
				{
					if (value2.CanReroll)
					{
						value2.pickup = pickup;
						value2.hidden = false;
					}
				}
				InstancedPurchases.UpdateAll(shop);
			}
			else
			{
				if ((whichStallsHaveBeenBoughtOnce.TryGetValue(component2, out var value) && value.Count > 0) || !component2.available || component.hasBeenPurchased || ((UniquePickup)(ref component.pickup)).Equals(UniquePickup.none) || !TryGenerateLunarShopPickup(out var pickup2))
				{
					yield break;
				}
				component.SetPickup(pickup2, false);
			}
			SpawnRerollEffect(shop, instance);
		}

		private void SpawnRerollEffect(GameObject shop, InstancedPurchase instance)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			if (EffectManager.DisableAllEffectSpawning)
			{
				return;
			}
			GameObject val = LunarRerollEffect.WaitForCompletion();
			EffectData val2 = new EffectData
			{
				origin = shop.transform.position + Vector3.up * 2.5f,
				rotation = Quaternion.identity,
				scale = 2f,
				color = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue)
			};
			if (!Object.op_Implicit((Object)(object)instance))
			{
				EffectManager.SpawnEffect(val, val2, true);
				return;
			}
			EffectMessage val3 = new EffectMessage
			{
				effectIndex = EffectCatalog.FindEffectIndexFromPrefab(val),
				effectData = val2
			};
			HashSet<NetworkConnection> hashSet = new HashSet<NetworkConnection>();
			foreach (PlayerCharacterMasterController instance2 in PlayerCharacterMasterController.instances)
			{
				if (Object.op_Implicit((Object)(object)instance2) && instance.GetOrOriginal(instance2).CanReroll)
				{
					NetworkConnection val4 = (Object.op_Implicit((Object)(object)instance2.networkUser) ? ((NetworkBehaviour)instance2.networkUser).connectionToClient : null);
					if (val4 != null && val4.isReady && hashSet.Add(val4))
					{
						val4.SendByChannel((short)52, (MessageBase)(object)val3, QosChannelIndex.effects.intVal);
					}
				}
			}
		}

		public static List<Vector2> GenerateCirclePoints(float radius, float startAngle, float endAngle, float orientation, int numberOfPoints)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			List<Vector2> list = new List<Vector2>();
			float num = (endAngle - startAngle) / (float)(numberOfPoints - 1);
			if (numberOfPoints <= 1)
			{
				num = 0f;
			}
			for (int i = 0; i < numberOfPoints; i++)
			{
				float num2 = (startAngle + (float)i * num + orientation) * (MathF.PI / 180f);
				float num3 = radius * Mathf.Cos(num2);
				float num4 = radius * Mathf.Sin(num2);
				list.Add(new Vector2(num3, num4));
			}
			return list;
		}

		private void SetLunarShopTerminal()
		{
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(-76.6438f, -24.0468f, -41.6449f);
			float orientation = 280f;
			float num = 140f;
			float num2 = 135f;
			float num3 = 123f;
			float num4 = 330f;
			float num5 = 325f;
			float num6 = 339f;
			List<Vector2> list = new List<Vector2>();
			int count = card.Count;
			if ((float)count <= 10f)
			{
				if ((float)count < 10f)
				{
					float num7 = num5 - num2;
					num2 += num7 / ((float)count + 1f);
					num5 -= num7 / ((float)count + 1f);
				}
				if (count >= 3 && count < 10)
				{
					float num8 = (10f - (float)count) / 7f;
					float num9 = (num2 + num5) / 2f;
					float num10 = Mathf.Min(num5 - num2 + 90f * num8, 180f);
					num2 = num9 - num10 / 2f;
					num5 = num9 + num10 / 2f;
				}
				list = GenerateCirclePoints(4f, num2, num5, orientation, count);
				list.Reverse();
			}
			else
			{
				new List<Vector2>();
				float num11 = (float)count * 3f / 8f;
				float num12 = (float)count * 5f / 8f;
				int num13 = Mathf.RoundToInt(num11);
				int num14 = Mathf.RoundToInt(num12);
				if (num13 + num14 != count)
				{
					float num15 = MathF.PI * 2f + 3f / (float)num13;
					float num16 = MathF.PI * 2f + 5f / (float)(count - num13);
					float num17 = MathF.PI * 2f + 3f / (float)num14;
					float num18 = MathF.PI * 2f + 5f / (float)(count - num14);
					if (Math.Abs(num15 - num16) < Math.Abs(num17 - num18))
					{
						num14 = count - num13;
					}
					else
					{
						num13 = count - num14;
					}
				}
				if ((float)count < 20f)
				{
					float num19 = num6 - num3;
					num3 += num19 / ((float)num14 + 1f);
					num6 -= num19 / ((float)num14 + 1f);
					num19 = num4 - num;
					num += num19 / ((float)num13 + 1f);
					num4 -= num19 / ((float)num13 + 1f);
				}
				List<Vector2> collection = GenerateCirclePoints(3f, num, num4, orientation, num13);
				List<Vector2> list2 = GenerateCirclePoints(5f, num3, num6, orientation, num14);
				list2.Reverse();
				list.AddRange(list2);
				list.AddRange(collection);
			}
			Vector3 position = default(Vector3);
			for (int i = 0; i < list.Count; i++)
			{
				Quaternion val2 = Quaternion.LookRotation(new Vector3(0f - list[i].x, 0f, 0f - list[i].y));
				if ((float)count > 10f)
				{
					Vector2 val3 = list[i];
					if (((Vector2)(ref val3)).magnitude < 4f)
					{
						val2 = Quaternion.LookRotation(new Vector3(list[i].x, 0f, list[i].y));
					}
				}
				val2 *= Quaternion.Euler(0f, 180f, 0f);
				((Vector3)(ref position))..ctor(val.x + list[i].x, val.y, val.z + list[i].y);
				DicLunarShopTerminals.Add(i, new SpawnCardStruct(position, ((Quaternion)(ref val2)).eulerAngles));
			}
		}

		private void DisableLunarBudPickupClearing(PurchaseInteraction purchaseInteraction, ShopTerminalBehavior shopTerminalBehavior)
		{
			PurchaseEvent onPurchase = purchaseInteraction.onPurchase;
			if (onPurchase == null)
			{
				Log.LogWarning("The bud's purchase event is missing");
				return;
			}
			for (int i = 0; i < ((UnityEventBase)onPurchase).GetPersistentEventCount(); i++)
			{
				if (((UnityEventBase)onPurchase).GetPersistentTarget(i) == (Object)(object)shopTerminalBehavior && ((UnityEventBase)onPurchase).GetPersistentMethodName(i) == "SetNoPickup")
				{
					((UnityEventBase)onPurchase).SetPersistentListenerState(i, (UnityEventCallState)0);
				}
			}
		}

		private void SpawnLunarShopTerminal()
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			if (ModCompatibilityQoLChests.enabled)
			{
				ModCompatibilityQoLChests.RegisterQoLChestsBlacklist("LunarShopTerminal_BazaarIsMyHaven");
			}
			ObjectLunarShopTerminals_Spawn.Clear();
			DicLunarShopTerminals.Clear();
			SetLunarShopTerminal();
			GameObject[] array = Object.FindObjectsOfType<GameObject>();
			foreach (GameObject val in array)
			{
				if (((Object)val).name.StartsWith("LunarShopTerminal"))
				{
					NetworkServer.Destroy(val);
				}
			}
			List<GameObject> list = BazaarBase.SpawnInSlots(DicLunarShopTerminals, lunarShopBud.WaitForCompletion(), 0, DicLunarShopTerminals.Count);
			ObjectLunarShopTerminals_Spawn.AddRange(list);
			for (int j = 0; j < list.Count; j++)
			{
				GameObject val2 = list[j];
				((Object)val2).name = "LunarShopTerminal_BazaarIsMyHaven";
				val2.transform.localScale = Vector3.one;
				PurchaseInteraction component = val2.GetComponent<PurchaseInteraction>();
				ShopTerminalBehavior component2 = val2.GetComponent<ShopTerminalBehavior>();
				DisableLunarBudPickupClearing(component, component2);
				if (ModConfig.LunarShopInstancedPurchases.Value)
				{
					InstancedPurchase instancedPurchase = val2.AddComponent<InstancedPurchase>();
					instancedPurchase.lunarShopIndex = j;
					instancedPurchase.original.available = component.available;
					instancedPurchase.original.pickup = component2.pickup;
					instancedPurchase.original.hasBeenPurchased = component2.hasBeenPurchased;
					instancedPurchase.original.hidden = component2.hidden;
				}
				whichStallsHaveBeenBoughtOnce.Add(component, new List<PlayerCharacterMasterController>());
			}
			LunarBudScaleSync.Apply(list);
		}
	}
	public class BazaarPrinter : BazaarBase
	{
		private class PrinterCard : DirectorCard
		{
			public readonly List<ItemTier> tiers = new List<ItemTier>();

			public PrinterCard()
				: base("Printer", null, ModConfig.PrinterDirectorWeight, () => ModConfig.PrinterMaxAmount.Value)
			{
			}

			protected override int CheapestCost()
			{
				List<(ItemTier, float)> tierChoices = GetTierChoices();
				if (tierChoices.Count != 0)
				{
					return tierChoices.Min<(ItemTier, float)>(((ItemTier tier, float weight) choice) => GetTierCost(choice.tier));
				}
				return int.MaxValue;
			}

			protected override int PickCost(int credits)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: 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)
				WeightedSelection<ItemTier> val = new WeightedSelection<ItemTier>(8);
				foreach (var tierChoice in GetTierChoices())
				{
					if (GetTierCost(tierChoice.tier) <= credits)
					{
						val.AddChoice(tierChoice.tier, tierChoice.weight);
					}
				}
				ItemTier val2 = val.Evaluate(Random.value);
				tiers.Add(val2);
				return GetTierCost(val2);
			}
		}

		private AsyncOperationHandle<InteractableSpawnCard> iscDuplicator;

		private AsyncOperationHandle<InteractableSpawnCard> iscDuplicatorLarge;

		private AsyncOperationHandle<InteractableSpawnCard> iscDuplicatorMilitary;

		private AsyncOperationHandle<InteractableSpawnCard> iscDuplicatorWild;

		private AsyncOperationHandle<InteractableSpawnCard>[] PrintersCode;

		private Dictionary<int, SpawnCardStruct> DicPrinters = new Dictionary<int, SpawnCardStruct>();

		private PrinterCard card;

		private int spawned;

		public override void Preload()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			iscDuplicator = Addressables.LoadAssetAsync<InteractableSpawnCard>((object)"RoR2/Base/Duplicator/iscDuplicator.asset");
			iscDuplicatorLarge = Addressables.LoadAssetAsync<InteractableSpawnCard>((object)"RoR2/Base/DuplicatorLarge/iscDuplicatorLarge.asset");
			iscDuplicatorMilitary = Addressables.LoadAssetAsync<InteractableSpawnCard>((object)"RoR2/Base/DuplicatorMilitary/iscDuplicatorMilitary.asset");
			iscDuplicatorWild = Addressables.LoadAssetAsync<InteractableSpawnCard>((object)"RoR2/Base/DuplicatorWild/iscDuplicatorWild.asset");
			PrintersCode = new AsyncOperationHandle<InteractableSpawnCard>[4] { iscDuplicator, iscDuplicatorLarge, iscDuplicatorMilitary, iscDuplicatorWild };
		}

		public override void Hook()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			ShopTerminalBehavior.SetPickup += new hook_SetPickup(ShopTerminalBehavior_SetPickup);
		}

		public override void RunStart()
		{
		}

		public override void AddDirectorCards(List<DirectorCard> cards)
		{
			card = null;
			if (ModConfig.PrinterSectionEnabled.Value)
			{
				if (GetTierChoices().Count == 0)
				{
					Log.LogWarning("No printer tiers with a valid weight; skipping printers.");
					return;
				}
				card = new PrinterCard();
				cards.Add(card);
			}
		}

		public override void SetupBazaar()
		{
			if (card != null)
			{
				DicPrinters.Clear();
				SetPrinter();
				spawned = 0;
				SpawnLatePicks();
			}
		}

		public override void SpawnLatePicks()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (card != null)
			{
				while (spawned < card.tiers.Count)
				{
					SpawnPrinter(card.tiers[spawned], DicPrinters[spawned]);
					spawned++;
				}
			}
		}

		private void ShopTerminalBehavior_SetPickup(orig_SetPickup orig, ShopTerminalBehavior self, UniquePickup newPickup, bool newHidden)
		{
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected I4, but got Unknown
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			WeightedSelection<List<PickupIndex>> weightedSelection;
			if (ModConfig.EnableMod.Value && ModConfig.PrinterSectionEnabled.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("Duplicator"))
			{
				string text = ((Object)self).name.Substring("Duplicator".Length);
				ItemTier result;
				bool flag = Enum.TryParse<ItemTier>(text, out result);
				if (text == "Void")
				{
					result = (ItemTier)5;
					flag = true;
				}
				if (flag)
				{
					weightedSelection = new WeightedSelection<List<PickupIndex>>(8);
					switch (result - 5)
					{
					case 1:
						AddDropList(Run.instance.availableVoidTier1DropList);
						break;
					case 2:
						AddDropList(Run.instance.availableVoidTier2DropList);
						break;
					case 3:
						AddDropList(Run.instance.availableVoidTier3DropList);
						break;
					case 4:
						AddDropList(Run.instance.availableVoidBossDropList);
						break;
					case 0:
						AddDropList(Run.instance.availableVoidTier1DropList);
						AddDropList(Run.instance.availableVoidTier2DropList);
						AddDropList(Run.instance.availableVoidTier3DropList);
						AddDropList(Run.instance.availableVoidBossDropList);
						break;
					}
					if (weightedSelection.Count > 0)
					{
						List<PickupIndex> list = weightedSelection.Evaluate(Random.value);
						newPickup.pickupIndex = list[Random.Range(0, list.Count)];
					}
				}
			}
			orig.Invoke(self, newPickup, newHidden);
			void AddDropList(List<PickupIndex> drops)
			{
				if (drops.Count > 0)
				{
					weightedSelection.AddChoice(drops, 25f);
				}
			}
		}

		private unsafe void SpawnPrinter(ItemTier tier, SpawnCardStruct slot)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected I4, but got Unknown
			SpawnCard val = null;
			string text = null;
			switch ((int)tier)
			{
			case 0:
				val = (SpawnCard)(object)iscDuplicator.WaitForCompletion();
				break;
			case 1:
				val = (SpawnCard)(object)iscDuplicatorLarge.WaitForCompletion();
				break;
			case 2:
				val = (SpawnCard)(object)iscDuplicatorMilitary.WaitForCompletion();
				break;
			case 4:
				val = (SpawnCard)(object)iscDuplicatorWild.WaitForCompletion();
				break;
			case 6:
			case 7:
			case 8:
			case 9:
				val = (SpawnCard)(object)iscDuplicatorMilitary.WaitForCompletion();
				text = "Duplicator" + ((object)(*(ItemTier*)(&tier))/*cast due to .constrained prefix*/).ToString();
				break;
			case 5:
				val = (SpawnCard)(object)iscDuplicatorMilitary.WaitForCompletion();
				text = "DuplicatorVoid";
				break;
			}
			GameObject val2 = BazaarBase.SpawnAt(val.prefab, slot);
			if (text != null)
			{
				((Object)val2).name = text;
			}
		}

		private static int GetTierCost(ItemTier tier)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected I4, but got Unknown
			return (int)tier switch
			{
				0 => Math.Max(0, ModConfig.PrinterDirectorCostWhite.Value), 
				1 => Math.Max(0, ModConfig.PrinterDirectorCostGreen.Value), 
				4 => Math.Max(0, ModConfig.PrinterDirectorCostBoss.Value), 
				_ => Math.Max(0, ModConfig.PrinterDirectorCostRed.Value), 
			};
		}

		private void SetPrinter()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
			List<int> list2 = new List<int>();
			while (list.Count > 0)
			{
				int index = RNG.Next(list.Count);
				list2.Add(list[index]);
				list.RemoveAt(index);
			}
			DicPrinters.Add(list2[0], new SpawnCardStruct(new Vector3(-112f, -26.8f, -46f), new Vector3(0f, 32.2f, 0f)));
			DicPrinters.Add(list2[1], new SpawnCardStruct(new Vector3(-108f, -26.8f, -48.5f), new Vector3(0f, 32.2f, 0f)));
			DicPrinters.Add(list2[2], new SpawnCardStruct(new Vector3(-104f, -26.7f, -51f), new Vector3(0f, 32.2f, 0f)));
			DicPrinters.Add(list2[3], new SpawnCardStruct(new Vector3(-127f, -26f, -34.5f), new Vector3(0f, 32.2f, 0f)));
			DicPrinters.Add(list2[4], new SpawnCardStruct(new Vector3(-131f, -26f, -31.8f), new Vector3(0f, 32.2f, 0f)));
			DicPrinters.Add(list2[5], new SpawnCardStruct(new Vector3(-135f, -26f, -29f), new Vector3(0f, 32.2f, 0f)));
			DicPrinters.Add(list2[6], new SpawnCardStruct(new Vector3(-144f, -24.7f, -24f), new Vector3(0f, 60.2f, 0f)));
			DicPrinters.Add(list2[7], new SpawnCardStruct(new Vector3(-145f, -25f, -20f), new Vector3(0f, 80f, 0f)));
			DicPrinters.Add(list2[8], new SpawnCardStruct(new Vector3(-146f, -25.3f, -16f), new Vector3(0f, 100f, 0f)));
		}

		private static List<(ItemTier tier, float weight)> GetTierChoices()
		{
			List<(ItemTier tier, float weight)> choices = new List<(ItemTier, float)>();
			AddTier((ItemTier)0, ModConfig.PrinterTier1Weight.Value, Run.instance.availableTier1DropList.Count);
			AddTier((ItemTier)1, ModConfig.PrinterTier2Weight.Value, Run.instance.availableTier2DropList.Count);
			AddTier((ItemTier)2, ModConfig.PrinterTier3Weight.Value, Run.instance.availableTier3DropList.Count);
			AddTier((ItemTier)4, ModConfig.PrinterTierBossWeight.Value, Run.instance.availableBossDropList.Count);
			AddTier((ItemTier)6, ModConfig.PrinterTierVoid1Weight.Value, Run.instance.availableVoidTier1DropList.Count);
			AddTier((ItemTier)7, ModConfig.PrinterTierVoid2Weight.Value, Run.instance.availableVoidTier2DropList.Count);
			AddTier((ItemTier)8, ModConfig.PrinterTierVoid3Weight.Value, Run.instance.availableVoidTier3DropList.Count);
			AddTier((ItemTier)9, ModConfig.PrinterTierVoidBossWeight.Value, Run.instance.availableVoidBossDropList.Count);
			int availableCount = Run.instance.availableVoidTier1DropList.Count + Run.instance.availableVoidTier2DropList.Count + Run.instance.availableVoidTier3DropList.Count + Run.instance.availableVoidBossDropList.Count;
			AddTier((ItemTier)5, ModConfig.PrinterTierVoidAnyWeight.Value, availableCount);
			return choices;
			void AddTier(ItemTier choice, float weight, int num)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				if (num > 0 && weight > 0f)
				{
					choices.Add((choice, weight));
				}
			}
		}
	}
	public class BazaarRestack : BazaarBase
	{
		private AsyncOperationHandle<InteractableSpawnCard> iscShrineRestack;

		private DirectorCard card;

		private bool spawned;

		public override void Preload()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			iscShrineRestack = Addressables.LoadAssetAsync<InteractableSpawnCard>((object)"RoR2/Base/ShrineRestack/iscShrineRestack.asset");
		}

		public override void Hook()
		{
		}

		public override void RunStart()
		{
		}

		public override void AddDirectorCards(List<DirectorCard> cards)
		{
			card = null;
			if (ModConfig.ShrineOfOrderSectionEnabled.Value)
			{
				card = new DirectorCard("Shrine of Order", ModConfig.ShrineOfOrderDirectorCost, ModConfig.ShrineOfOrderDirectorWeight, () => 1);
				cards.Add(card);
			}
		}

		public override void SetupBazaar()
		{
			spawned = false;
			SpawnLatePicks();
		}

		public override void SpawnLatePicks()
		{
			if (card != null && card.Count != 0 && !spawned)
			{
				SpawnShrineRestack();
				spawned = true;
			}
		}

		private void SpawnShrineRestack()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = BazaarBase.SpawnAt(((SpawnCard)iscShrineRestack.WaitForCompletion()).prefab, new SpawnCardStruct(new Vector3(-130f, -24f, -40f), new Vector3(0f, 220f, 0f)));
			if (ModConfig.ShrineOfOrderUseLimit.Value >= 0)
			{
				val.GetComponent<ShrineRestackBehavior>().maxPurchaseCount = ModConfig.ShrineOfOrderUseLimit.Value;
			}
			else
			{
				val.GetComponent<ShrineRestackBehavior>().maxPurchaseCount = int.MaxValue;
			}
			val.GetComponent<ShrineRestackBehavior>().costMultiplierPerPurchase = 1f;
			val.GetComponent<PurchaseInteraction>().cost = ModConfig.ShrineOfOrderCost.Value;
			val.GetComponent<PurchaseInteraction>().Networkcost = ModConfig.ShrineOfOrderCost.Value;
		}
	}
	public class BazaarScrapper : BazaarBase
	{
		private AsyncOperationHandle<InteractableSpawnCard> iscScrapper;

		private Dictionary<int, SpawnCardStruct> DicScrapers = new Dictionary<int, SpawnCardStruct>();

		private DirectorCard card;

		private bool spawned;

		public override void Preload()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			iscScrapper = Addressables.LoadAssetAsync<InteractableSpawnCard>((object)"RoR2/Base/Scrapper/iscScrapper.asset");
		}

		public override void Hook()
		{
		}

		public override void RunStart()
		{
		}

		public override void AddDirectorCards(List<DirectorCard> cards)
		{
			card = null;
			if (ModConfig.ScrapperSectionEnabled.Value)
			{
				card = new DirectorCard("Scrappers", ModConfig.ScrapperDirectorCost, ModConfig.ScrapperDirectorWeight, () => (ModConfig.ScrapperMaxAmount.Value > 0) ? 1 : 0);
				cards.Add(card);
			}
		}

		public override void SetupBazaar()
		{
			spawned = false;
			SpawnLatePicks();
		}

		public override void SpawnLatePicks()
		{
			if (card != null && card.Count != 0 && !spawned)
			{
				DicScrapers.Clear();
				SetScraper();
				BazaarBase.SpawnInSlots(DicScrapers, ((SpawnCard)iscScrapper.WaitForCompletion()).prefab, 0, ModConfig.ScrapperMaxAmount.Value);
				spawned = true;
			}
		}

		private void SetScraper()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = new List<int> { 0, 1 };
			List<int> list2 = new List<int>();
			while (list.Count > 0)
			{
				int index = RNG.Next(list.Count);
				list2.Add(list[index]);
				list.RemoveAt(index);
			}
			DicScrapers.Add(list2[0], new SpawnCardStruct(new Vector3(-100f, -25f, -40f), new Vector3(0f, 72f, 0f)));
			DicScrapers.Add(list2[1], new SpawnCardStruct(new Vector3(-95f, -25.5f, -35f), new Vector3(0f, 72f, 0f)));
		}
	}
	public class BazaarWanderingChef : BazaarBase
	{
		private AsyncOperationHandle<GameObject> mealPrep;

		private AsyncOperationHandle<GameObject> ChefWok_WhitesAndGreens;

		private Dictionary<PickupIndex, List<RecipeEntry>> allAvailableRecipes;

		private PickupIndex[] allAvailableTargetPickupIndexes;

		private int randomTargetPickupIndex;

		private List<RecipeEntry> possibleRecipes;

		private ShopTerminalBehavior cauldron;

		private GameObject chef;

		private DirectorCard card;

		public override void Preload()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			mealPrep = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC3/MealPrep/MealPrep.prefab");
			ChefWok_WhitesAndGreens = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC3/MealPrep/ChefWok, WhitesAndGreens.prefab");
		}

		public override void Hook()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			ShopTerminalBehavior.SetPickup += new hook_SetPickup(ShopTerminalBehavior_SetPickup);
			CraftingController.AttemptFindPossibleRecipes += new hook_AttemptFindPossibleRecipes(CraftingController_AttemptFindPossibleRecipes);
			CraftingController.GetGeneratedOptionsFromInteractor += new hook_GetGeneratedOptionsFromInteractor(CraftingController_GetGeneratedOptionsFromInteractor);
			CraftingController.CanTakePickupAfterUseByIngredientSlots += new hook_CanTakePickupAfterUseByIngredientSlots(CraftingController_CanTakePickupAfterUseByIngredientSlots);
			MealPrepController.BeginCookingServer += new hook_BeginCookingServer(MealPrepController_BeginCookingServer);
		}

		public override void RunStart()
		{
			RunEnd();
			if (ModConfig.WanderingChefSectionEnabled.Value && IsAlloyedCollectiveEnabled() && !ModConfig.WanderingChefUnrestrictedCrafting.Value)
			{
				allAvailableRecipes = GetAvailableRecipes();
				allAvailableTargetPickupIndexes = allAvailableRecipes.Keys.ToArray();
				randomTargetPickupIndex = RNG.Next(allAvailableTargetPickupIndexes.Length);
			}
		}

		public override void RunEnd()
		{
			allAvailableRecipes = null;
			allAvailableTargetPickupIndexes = null;
			possibleRecipes = null;
			cauldron = null;
		}

		private static bool IsAlloyedCollectiveEnabled()
		{
			if (Object.op_Implicit((Object)(object)DLC3Content.DLC3) && Object.op_Implicit((Object)(object)Run.instance))
			{
				return Run.instance.IsExpansionEnabled(DLC3Content.DLC3);
			}
			return false;
		}

		public override void AddDirectorCards(List<DirectorCard> cards)
		{
			card = null;
			if (!ModConfig.WanderingChefSectionEnabled.Value || !IsAlloyedCollectiveEnabled())
			{
				return;
			}
			if (!ModConfig.WanderingChefUnrestrictedCrafting.Value && (allAvailableTargetPickupIndexes == null || allAvailableTargetPickupIndexes.Length == 0))
			{
				Log.LogWarning("No recipes; skipping the Wandering Chef this visit.");
				return;
			}
			card = new DirectorCard("Wandering CHEF", ModConfig.WanderingChefDirectorCost, ModConfig.WanderingChefDirectorWeight, () => 1, null, allowLatePicks: false);
			cards.Add(card);
		}

		public override void SetupBazaar()
		{
			chef = null;
			cauldron = null;
			if (card != null && card.Count > 0)
			{
				SpawnWanderingChef();
			}
		}

		public override int CheckAfterSetup()
		{
			if (!Object.op_Implicit((Object)(object)chef) || ModConfig.WanderingChefUnrestrictedCrafting.Value || !ModConfig.WanderingChefCraftableRecipesOnly.Value)
			{
				return 0;
			}
			if (TryChooseCraftableRecipe())
			{
				return 0;
			}
			Log.LogInfo("No craftable recipe for the Wandering Chef; the director spends his credits on something else.");
			NetworkServer.Destroy(chef);
			if (Object.op_Implicit((Object)(object)cauldron))
			{
				NetworkServer.Destroy(((Component)cauldron).gameObject);
			}
			chef = null;
			cauldron = null;
			return card.Spent;
		}

		private void ShopTerminalBehavior_SetPickup(orig_SetPickup orig, ShopTerminalBehavior self, UniquePickup newPickup, bool newHidden)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.EnableMod.Value && ModConfig.WanderingChefSectionEnabled.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("CookingCauldron"))
			{
				if (possibleRecipes == null || possibleRecipes.Count == 0)
				{
					newPickup.pickupIndex = PickupIndex.none;
				}
				else
				{
					newPickup.pickupIndex = possibleRecipes[0].result;
				}
			}
			orig.Invoke(self, newPickup, newHidden);
		}

		private void CraftingController_AttemptFindPossibleRecipes(orig_AttemptFindPossibleRecipes orig, CraftingController self)
		{
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.EnableMod.Value && ModConfig.WanderingChefSectionEnabled.Value && !ModConfig.WanderingChefUnrestrictedCrafting.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("WanderingChef") && possibleRecipes != null && possibleRecipes.Count > 0)
			{
				self._possibleRecipes = possibleRecipes.ToArray();
				if (!self.AllSlotsEmpty())
				{
					self._possibleRecipes = FindRecipesThatCanAcceptIngredients(self.ingredients);
				}
				CraftableCatalog.FilterByEntitlement(ref self._possibleRecipes);
				if (!self.AllSlotsFilled())
				{
					return;
				}
				self.bestFitRecipe = null;
				for (int i = 0; i < self._possibleRecipes.Length; i++)
				{
					RecipeEntry val = self._possibleRecipes[i];
					if (val != null && CraftableCatalog.ValidateRecipe(val, self.ingredients))
					{
						self.bestFitRecipe = val;
					}
				}
				if (self.bestFitRecipe != null)
				{
					self.result = self.bestFitRecipe.result;
					self.amountToDrop = self.bestFitRecipe.amountToDrop;
					((NetworkBehaviour)self).SetDirtyBit(CraftingController.resultDirtyBit);
				}
			}
			else
			{
				orig.Invoke(self);
			}
		}

		private List<Option> CraftingController_GetGeneratedOptionsFromInteractor(orig_GetGeneratedOptionsFromInteractor orig, CraftingController self, Interactor activator)
		{
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			List<Option> result = orig.Invoke(self, activator);
			if (ModConfig.EnableMod.Value && ModConfig.WanderingChefSectionEnabled.Value && !ModConfig.WanderingChefUnrestrictedCrafting.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("WanderingChef") && possibleRecipes != null && possibleRecipes.Count > 0)
			{
				CharacterBody component = ((Component)activator).GetComponent<CharacterBody>();
				if ((Object)(object)component != (Object)null)
				{
					List<Option> list = new List<Option>();
					HashSet<PickupIndex> hashSet = new HashSet<PickupIndex>();
					foreach (RecipeEntry possibleRecipe in possibleRecipes)
					{
						IngredientSlotEntry[] possibleIngredients = possibleRecipe.possibleIngredients;
						for (int i = 0; i < possibleIngredients.Length; i++)
						{
							PickupIndex[] pickups = possibleIngredients[i].pickups;
							foreach (PickupIndex item in pickups)
							{
								hashSet.Add(item);
							}
						}
					}
					{
						foreach (PickupIndex item2 in hashSet)
						{
							list.Add(new Option
							{
								available = InventoryContainsPickup(component.inventory, item2),
								pickup = new UniquePickup(item2)
							});
						}
						return list;
					}
				}
			}
			return result;
		}

		private bool CraftingController_CanTakePickupAfterUseByIngredientSlots(orig_CanTakePickupAfterUseByIngredientSlots orig, CraftingController self, PickupIndex pickupIndex, PickupIndex[] consumedIngredients)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Invalid comparison between Unknown and I4
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.EnableMod.Value && ModConfig.WanderingChefSectionEnabled.Value && !ModConfig.WanderingChefUnrestrictedCrafting.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("WanderingChef"))
			{
				CharacterMaster currentParticipantMaster = ((PickupPickerController)self).networkUIPromptController.currentParticipantMaster;
				if (Object.op_Implicit((Object)(object)currentParticipantMaster))
				{
					PickupDef pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
					if (pickupDef != null)
					{
						Inventory inventory = currentParticipantMaster.inventory;
						if ((int)pickupDef.itemIndex != -1)
						{
							int num = consumedIngredients.Count((PickupIndex p) => p == pickupIndex);
							if (Object.op_Implicit((Object)(object)inventory))
							{
								return num < inventory.GetItemCountPermanent(pickupDef.itemIndex);
							}
						}
						else if ((int)pickupDef.equipmentIndex != -1)
						{
							return consumedIngredients.Count((PickupIndex pickup) => pickup == pickupIndex) < InventoryPickupCount(inventory, pickupDef.pickupIndex);
						}
					}
				}
				return false;
			}
			return orig.Invoke(self, pickupIndex, consumedIngredients);
		}

		private void MealPrepController_BeginCookingServer(orig_BeginCookingServer orig, MealPrepController self, Interactor activator, PickupIndex[] itemsToTake, PickupIndex reward, int count)
		{
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Invalid comparison between Unknown and I4
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Invalid comparison between Unknown and I4
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.EnableMod.Value && ModConfig.WanderingChefSectionEnabled.Value && ModConfig.WanderingChefBuyToInventory.Value && IsCurrentMapInBazaar() && NetworkServer.active && ((Object)self).name.StartsWith("WanderingChef"))
			{
				CharacterBody component = ((Component)activator).GetComponent<CharacterBody>();
				Inventory inventory = component.inventory;
				if (!self.IsAffordable(itemsToTake, component))
				{
					return;
				}
				for (int i = 0; i < itemsToTake.Length; i++)
				{
					PickupDef pickupDef = PickupCatalog.GetPickupDef(itemsToTake[i]);
					ItemIndex itemIndex = pickupDef.itemIndex;
					EquipmentIndex equipmentIndex = pickupDef.equipmentIndex;
					self.CreateItemTakenOrb(((Component)activator).transform.position, ((Component)self).gameObject, pickupDef.pickupIndex);
					if ((int)itemIndex != -1)
					{
						inventory.RemoveItemPermanent(itemIndex, 1);
					}
					else if ((int)equipmentIndex != -1)
					{
						inventory.RemoveEquipment(equipmentIndex);
					}
				}
				Dictionary<PickupIndex, int> dictionary = new Dictionary<PickupIndex, int>();
				dictionary[reward] = count;
				Helper.GivePickups(component, dictionary, null, dropReplacedEquipmentsAsPickupDroplets: false);
			}
			else
			{
				orig.Invoke(self, activator, itemsToTake, reward, count);
			}
		}

		private bool InventoryContainsPickup(Inventory inventory, PickupIndex pickup)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return InventoryPickupCount(inventory, pickup) > 0;
		}

		private int InventoryPickupCount(Inventory inventory, PickupIndex pickup)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			//IL_0020: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			PickupDef pickupDef = ((PickupIndex)(ref pickup)).pickupDef;
			if (!Object.op_Implicit((Object)(object)inventory) || pickupDef == null)
			{
				return 0;
			}
			if ((int)pickupDef.itemIndex != -1)
			{
				return inventory.GetItemCountPermanent(pickupDef.itemIndex);
			}
			int num = 0;
			if ((int)pickupDef.equipmentIndex != -1)
			{
				for (uint num2 = 0u; num2 < inventory.GetEquipmentSlotCount(); num2++)
				{
					for (uint num3 = 0u; num3 < inventory.GetEquipmentSetCount(); num3++)
					{
						EquipmentLocation val = new EquipmentLocation
						{
							slot = num2,
							set = num3
						};
						if (inventory.GetEquipment(ref val).equipmentIndex == pickupDef.equipmentIndex)
						{
							num++;
						}
					}
				}
			}
			return num;
		}

		public RecipeEntry[] FindRecipesThatCanAcceptIngredients(PickupIndex[] choices)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			List<RecipeEntry> allRecipes = CraftableCatalog.allRecipes;
			if (possibleRecipes != null && possibleRecipes.Count > 0)
			{
				allRecipes = possibleRecipes;
			}
			if (choices.Length == 0)
			{
				return allRecipes.ToArray();
			}
			List<RecipeEntry> list = new List<RecipeEntry>();
			foreach (RecipeEntry item in allRecipes)
			{
				foreach (PickupIndex val in choices)
				{
					if (item.recipe.CheckIfValidIngredient(val))
					{
						list.Add(item);
						break;
					}
				}
			}
			return list.ToArray();
		}

		private Dictionary<PickupIndex, List<RecipeEntry>> GetAvailableRecipes()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Invalid comparison between Unknown and I4
			//IL_0042: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<PickupIndex, List<RecipeEntry>> dictionary = new Dictionary<PickupIndex, List<RecipeEntry>>();
			RecipeEntry[] allRecipes = CraftableCatalog.GetAllRecipes();
			foreach (RecipeEntry val in allRecipes)
			{
				bool flag = false;
				if ((int)((PickupIndex)(ref val.result)).pickupDef.itemIndex != -1)
				{
					flag = Run.instance.availableItems.Contains(((PickupIndex)(ref val.result)).pickupDef.itemIndex);
					if (ItemCatalog.GetItemDef(((PickupIndex)(ref val.result)).pickupDef.itemIndex).ContainsTag((ItemTag)32))
					{
						flag = false;
					}
				}
				if ((int)((PickupIndex)(ref val.result)).pickupDef.equipmentIndex != -1)
				{
					flag = Run.instance.availableEquipment.Contains(((PickupIndex)(ref val.result)).pickupDef.equipmentIndex);
				}
				if (flag)
				{
					bool flag2 = true;
					IngredientSlotEntry[] possibleIngredients = val.possibleIngredients;
					foreach (IngredientSlotEntry obj in possibleIngredients)
					{
						HashSet<PickupIndex> hashSet = new HashSet<PickupIndex>();
						bool flag3 = false;
						PickupIndex[] pickups = obj.pickups;
						foreach (PickupIndex val2 in pickups)
						{
							if (Run.instance.IsPickupAvailable(val2))
							{
								flag3 = true;
								break;
							}
							hashSet.Add(val2);
						}
						if (!flag3)
						{
							flag2 = false;
							Log.LogDebug(string.Format("Recipe for {0} cannot be added because of missing ingredients: {1}", val.result, string.Join(", ", hashSet)));
							break;
						}
					}
					if (flag2)
					{
						List<RecipeEntry> valueOrDefault = dictionary.GetValueOrDefault(val.result, new List<RecipeEntry>());
						valueOrDefault.Add(val);
						dictionary[val.result] = valueOrDefault;
					}
				}
				else
				{
					Log.LogDebug($"Recipe for {val.result} cannot be added because target not in available items.");
				}
			}
			return dictionary;
		}

		public void NextRecipe()
		{
			//IL_003c: 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_0048: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (allAvailableTargetPickupIndexes != null && allAvailableTargetPickupIndexes.Length != 0 && allAvailableRecipes != null)
			{
				randomTargetPickupIndex = (randomTargetPickupIndex + 1) % allAvailableTargetPickupIndexes.Length;
				PickupIndex val = allAvailableTargetPickupIndexes[randomTargetPickupIndex];
				_ = allAvailableRecipes[val];
				if (val != PickupIndex.none)
				{
					possibleRecipes = allAvailableRecipes[val];
				}
				if ((Object)(object)cauldron != (Object)null)
				{
					cauldron.GenerateNewPickupServer();
				}
			}
		}

		private bool TryChooseCraftableRecipe()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if (allAvailableTargetPickupIndexes == null || allAvailableTargetPickupIndexes.Length == 0 || allAvailableRecipes == null)
			{
				return false;
			}
			List<(Inventory inventory, HashSet<PickupIndex> bazaarStock, HashSet<PickupIndex> pedestalChoices)> players = GetPlayerIngredients();
			for (int i = 1; i <= allAvailableTargetPickupIndexes.Length; i++)
			{
				int num = (randomTargetPickupIndex + i) % allAvailableTargetPickupIndexes.Length;
				List<RecipeEntry> list = allAvailableRecipes[allAvailableTargetPickupIndexes[num]].Where((RecipeEntry recipe) => IsCraftable(recipe, players)).ToList();
				if (list.Count > 0)
				{
					randomTargetPickupIndex = num;
					possibleRecipes = list;
					if (Object.op_Implicit((Object)(object)cauldron))
					{
						cauldron.GenerateNewPickupServer();
					}
					return true;
				}
			}
			return false;
		}

		private bool IsCraftable(RecipeEntry recipe, List<(Inventory inventory, HashSet<PickupIndex> bazaarStock, HashSet<PickupIndex> pedestalChoices)> players)
		{
			return players.Any(delegate((Inventory inventory, HashSet<PickupIndex> bazaarStock, HashSet<PickupIndex> pedestalChoices) player)
			{
				List<IngredientSlotEntry> list = recipe.possibleIngredients.Where((IngredientSlotEntry slot) => slot.pickups == null || !slot.pickups.Any((PickupIndex pickup) => player.bazaarStock.Contains(pickup) || InventoryContainsPickup(player.inventory, pickup))).ToList();
				return list.Count == 0 || (list.Count == 1 && list[0].pickups != null && list[0].pickups.Any(player.pedestalChoices.Contains));
			});
		}

		private List<(Inventory inventory, HashSet<PickupIndex> bazaarStock, HashSet<PickupIndex> pedestalChoices)> GetPlayerIngredients()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			ShopTerminalBehavior[] array = Object.FindObjectsOfType<ShopTerminalBehavior>();
			bool flag = Object.op_Implicit((Object)(object)Object.FindObjectOfType<ScrapperController>());
			List<(Inventory, HashSet<PickupIndex>, HashSet<PickupIndex>)> list = new List<(Inventory, HashSet<PickupIndex>, HashSet<PickupIndex>)>();
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				Inventory val = ((Object.op_Implicit((Object)(object)instance) && Object.op_Implicit((Object)(object)instance.master)) ? instance.master.inventory : null);
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				HashSet<PickupIndex> hashSet = new HashSet<PickupIndex>();
				ShopTerminalBehavior[] array2 = array;
				foreach (ShopTerminalBehavior val2 in array2)
				{
					PickupIndex val3 = (((Object)(object)val2 != (Object)(object)cauldron) ? GetBuyablePickup(val2, instance) : PickupIndex.none);
					if (val3 != PickupIndex.none)
					{
						hashSet.Add(val3);
					}
				}
				HashSet<PickupIndex> hashSet2 = new HashSet<PickupIndex>();
				if (BazaarCommandPedestal.instance != null)
				{
					hashSet2.UnionWith(BazaarCommandPedestal.instance.GetChoicesFor(instance));
				}
				if (flag)
				{
					AddScrap(hashSet, val, (ItemTier)0, Items.ScrapWhite);
					AddScrap(hashSet, val, (ItemTier)1, Items.ScrapGreen);
					AddScrap(hashSet, val, (ItemTier)2, Items.ScrapRed);
					AddScrap(hashSet, val, (ItemTier)4, Items.ScrapYellow);
				}
				list.Add((val, hashSet, hashSet2));
			}
			return list;
		}

		private static PickupIndex GetBuyablePickup(ShopTerminalBehavior terminal, PlayerCharacterMasterController pc)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			if (((Component)terminal).TryGetComponent<InstancedPurchase>(ref instancedPurchase))
			{
				InstancedPurchaseStruct orOriginal = instancedPurchase.GetOrOriginal(pc);
				if (!orOriginal.available || orOriginal.hasBeenPurchased)
				{
					return PickupIndex.none;
				}
				return orOriginal.pickup.pickupIndex;
			}
			PurchaseInteraction component = ((Component)terminal).GetComponent<PurchaseInteraction>();
			if (!Object.op_Implicit((Object)(object)component) || !component.available || terminal.hasBeenPurchased)
			{
				return PickupIndex.none;
			}
			return terminal.pickup.pickupIndex;
		}

		private static void AddScrap(HashSet<PickupIndex> bazaarStock, Inventory inventory, ItemTier tier, ItemDef scrap)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)scrap) && inventory.GetTotalItemCountOfTier(tier) > 0)
			{
				bazaarStock.Add(PickupCatalog.FindPickupIndex(scrap.itemIndex));
			}
		}

		private void SpawnWanderingChef()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			SpawnCardStruct spawnCardStruct = new SpawnCardStruct(new Vector3(-70.7306f, -23.7171f, -30.4022f), new Vector3(0f, 220f, 0f));
			SpawnCardStruct spawnCardStruct2 = new SpawnCardStruct(new Vector3(-72.4183f, -24.4958f, -28.9289f), new Vector3(0f, 220f, 0f));
			if (!ModConfig.WanderingChefUnrestrictedCrafting.Value)
			{
				if (ModConfig.WanderingChefCraftableRecipesOnly.Value)
				{
					possibleRecipes = null;
				}
				else
				{
					NextRecipe();
				}
			}
			GameObject val = Object.Instantiate<GameObject>(mealPrep.WaitForCompletion(), spawnCardStruct.Position, Quaternion.identity);
			val.transform.eulerAngles = spawnCardStruct.Rotation;
			((Object)val).name = "WanderingChef";
			NetworkServer.Spawn(val);
			chef = val;
			val = Object.Instantiate<GameObject>(ChefWok_WhitesAndGreens.WaitForCompletion(), spawnCardStruct2.Position, Quaternion.identity);
			val.transform.eulerAngles = spawnCardStruct2.Rotation;
			((Object)val).name = "CookingCauldron";
			PurchaseInteraction component = val.GetComponent<PurchaseInteraction>();
			component.NetworkcostType = (CostTypeIndex)0;
			component.Networkavailable = false;
			cauldron = val.GetComponent<ShopTerminalBehavior>();
			NetworkServer.Spawn(val);
		}
	}
	public class Helper
	{
		public static PlayerCharacterMasterController GetHostPlayer()
		{
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				if (Object.op_Implicit((Object)(object)instance) && ((NetworkBehaviour)instance).hasAuthority)
				{
					return instance;
				}
			}
			return null;
		}

		public static int GetCost(int cost, CostTypeIndex costType)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			if (ModConfig.ScaleMoneyCosts.Value && (int)costType == 1 && Object.op_Implicit((Object)(object)Run.instance))
			{
				return Run.instance.GetDifficultyScaledCost(cost);
			}
			return cost;
		}

		public static bool CanAfford(CostTypeIndex costType, int cost, Interactor activator, CharacterBody body)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			CostTypeDef costTypeDef = CostTypeCatalog.GetCostTypeDef(costType);
			if (costTypeDef != null)
			{
				return costTypeDef.IsAffordable(TeamManager.AdjustCostForLongstandingSolitude(costType, cost, body), activator);
			}
			return false;
		}

		public static void PayCost(CostTypeIndex costType, int cost, Interactor activator, CharacterBody body, GameObject purchasedObject, Xoroshiro128Plus rng)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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)
			CostTypeDef costTypeDef = CostTypeCatalog.GetCostTypeDef(costType);
			int num = TeamManager.AdjustCostForLongstandingSolitude(costType, cost, body);
			foreach (ItemAndStackValues item in costTypeDef.PayCost(num, activator, purchasedObject, rng, (ItemIndex)(-1)).itemStacksTaken)
			{
				for (int i = 0; i < item.stackValues.totalStacks; i++)
				{
					PurchaseInteraction.CreateItemTakenOrb(body.corePosition, purchasedObject, item.itemIndex);
				}
			}
		}

		public static void CreateItemTakenOrb(Vector3 effectOrigin, GameObject targetObject, PickupIndex pickupIndex)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			if (NetworkServer.active)
			{
				EffectData val = new EffectData
				{
					origin = effectOrigin,
					genericFloat = 1.5f,
					genericUInt = (uint)(pickupIndex.value + 1)
				};
				val.SetNetworkedObjectReference(targetObject);
				EffectManager.SpawnEffect(Main.instance.pickupTakenOrbPrefab.WaitForCompletion(), val, true);
			}
		}

		public static EquipmentIndex GivePickup(CharacterBody characterBody, PickupIndex pickupToGive, Vector3 itemOrbSource, bool dropReplacedEquipmentAsPickupDroplet)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<PickupIndex, int> dictionary = new Dictionary<PickupIndex, int>();
			dictionary[pickupToGive] = 1;
			foreach (var (result, num2) in GivePickups(characterBody, dictionary, itemOrbSource, dropReplacedEquipmentAsPickupDroplet))
			{
				if (num2 > 0)
				{
					return result;
				}
			}
			return (EquipmentIndex)(-1);
		}

		public static Dictionary<EquipmentIndex, int> GivePickups(CharacterBody characterBody, Dictionary<PickupIndex, int> itemsToGive, Vector3? itemOrbSource, bool dropReplacedEquipmentsAsPickupDroplets)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<EquipmentIndex, int> dictionary = new Dictionary<EquipmentIndex, int>();
			if (!Object.op_Implicit((Object)(object)characterBody) || itemsToGive == null)
			{
				return dictionary;
			}
			if (itemOrbSource.HasValue)
			{
				int num = 0;
				foreach (var (pickupIndex, num3) in itemsToGive)
				{
					if (num3 > 0 && num < 20)
					{
						CreateItemTakenOrb(itemOrbSource.Value, ((Component)characterBody).gameObject, pickupIndex);
						num++;
					}
				}
			}
			foreach (UniquePickup item in ItemStringParser.GivePickups(characterBody, itemsToGive))
			{
				PickupDef pickupDef = PickupCatalog.GetPickupDef(item.pickupIndex);
				EquipmentIndex val2 = (EquipmentIndex)((pickupDef == null) ? (-1) : ((int)pickupDef.equipmentIndex));
				if ((int)val2 != -1)
				{
					dictionary[val2] = dictionary.GetValueOrDefault(val2) + 1;
				}
				if (dropReplacedEquipmentsAsPickupDroplets)
				{
					PickupDropletController.CreatePickupDroplet(item, characterBody.corePosition + Vector3.up * 1.5f, Vector3.up * 15f - characterBody.coreTransform.forward * 15f, false);
				}
			}
			return dictionary;
		}
	}
	public class CatalogHelper
	{
		public static BodyIndex FindBody(string survivorOrBodyName)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			return BodyCatalog.FindBodyIndexCaseInsensitive(survivorOrBodyName.EndsWith("Body", StringComparison.InvariantCultureIgnoreCase) ? survivorOrBodyName : (survivorOrBodyName + "Body"));
		}
	}
	internal class ChatHelper
	{
		private static Random Random = new Random();

		private const string GrayColor = "7e91af";

		private const string RedColor = "ed4c40";

		private const string LunarColor = "5cb1ed";

		private static string NewtName => Language.GetString("SHOPKEEPER_BODY_NAME");

		private static string GetPlayerColor(PlayerCharacterMasterController pc)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)pc))
			{
				return "f27b0c";
			}
			SurvivorDef val = SurvivorCatalog.FindSurvivorDefFromBody(pc.master?.bodyPrefab);
			if ((Object)(object)val != (Object)null)
			{
				return ColorUtility.ToHtmlStringRGB(val.primaryColor);
			}
			CharacterMaster master = pc.master;
			CharacterBody val2 = ((master != null) ? master.GetBody() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				return ColorUtility.ToHtmlStringRGB(val2.bodyColor);
			}
			return "f27b0c";
		}

		private static string GetColoredPlayerName(PlayerCharacterMasterController playerCharacterMasterController)
		{
			string playerColor = GetPlayerColor(playerCharacterMasterController);
			string text = (Object.op_Implicit((Object)(object)playerCharacterMasterController) ? playerCharacterMasterController.GetDisplayName() : "Player");
			return "<color=#" + playerColor + ">" + text + "</color>";
		}

		public static void LunarShopTerminalUsesLeft(PlayerCharacterMasterController playerCharacterMasterController, int usesLeft)
		{
			string coloredPlayerName = GetColoredPlayerName(playerCharacterMasterController);
			if (usesLeft > 1)
			{
				Send(string.Format("{0} <color=#{1}>can use a shop terminal</color> <color=#{2}>{3}</color> <color=#{4}>more times.</color>", coloredPlayerName, "7e91af", "ed4c40", usesLeft, "7e91af"));
			}
			else if (usesLeft == 1)
			{
				Send(string.Format("{0} <color=#{1}>can use a shop terminal</color> <color=#{2}>{3}</color> <color=#{4}>more time.</color>", coloredPlayerName, "7e91af", "ed4c40", usesLeft, "7e91af"));
			}
			else
			{
				Send(coloredPlayerName + " <color=#7e91af>can no longer use shop terminals.</color>");
			}
		}

		public static void LunarRecyclerUsesLeft(int usesLeft)
		{
			if (usesLeft > 1)
			{
				Send(string.Format("The <color=#{0}>Lunar Recycler</color> <color=#{1}>can be used</color> <color=#{2}>{3}</color> <color=#{4}>more times.</color>", "5cb1ed", "7e91af", "ed4c40", usesLeft, "7e91af"));
			}
			else if (usesLeft == 1)
			{
				Send(string.Format("The <color=#{0}>Lunar Recycler</color> <color=#{1}>can be used</color> <color=#{2}>{3}</color> <color=#{4}>more time.</color>", "5cb1ed", "7e91af", "ed4c40", usesLeft, "7e91af"));
			}
			else
			{
				Send("The <color=#5cb1ed>Lunar Recycler</color> <color=#7e91af>can no longer be used.</color>");
			}
		}

		private static string GetDeathState()
		{
			if (!ShopKeeper.DiedAtLeastOnce || ModConfig.NewtDeathBehavior.Value != ShopKeeper.DeathState.Ghost)
			{
				return "";
			}
			return " (" + Language.GetString(LanguageAPI.NEWT_DEATH_STATE) + ")";
		}

		public static string GetItemNames(Dictionary<PickupIndex, int> pickupIndexes)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Invalid comparison between Unknown and I4
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			foreach (var (val2, num2) in pickupIndexes)
			{
				if (num2 <= 0)
				{
					continue;
				}
				PickupDef pickupDef = PickupCatalog.GetPickupDef(val2);
				if (pickupDef == null)
				{
					continue;
				}
				string text = pickupDef.internalName;
				ColorIndex val3 = (ColorIndex)1;
				if ((int)pickupDef.itemIndex != -1)
				{
					ItemDef itemDef = ItemCatalog.GetItemDef(pickupDef.itemIndex);
					text = ((!string.IsNullOrWhiteSpace(itemDef.nameToken)) ? Language.GetString(itemDef.nameToken) : ((Object)itemDef).name);
					if (string.IsNullOrWhiteSpace(text))
					{
						text = ((Object)itemDef).name;
					}
					ItemTierDef itemTierDef = ItemTierCatalog.GetItemTierDef(itemDef.tier);
					if (Object.op_Implicit((Object)(object)itemTierDef))
					{
						val3 = itemTierDef.colorIndex;
					}
				}
				else if ((int)pickupDef.equipmentIndex != -1)
				{
					EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(pickupDef.equipmentIndex);
					text = ((!string.IsNullOrWhiteSpace(equipmentDef.nameToken)) ? Language.GetString(equipmentDef.nameToken) : ((Object)equipmentDef).name);
					if (string.IsNullOrWhiteSpace(text))
					{
						text = ((Object)equipmentDef).name;
					}
					val3 = equipmentDef.colorIndex;
				}
				string colorHexString = ColorCatalog.GetColorHexString(val3);
				if (num2 > 1)
				{
					list.Add($"<color=#{colorHexString}>{text}</color> x {num2}");
					continue;
				}
				list.Add("<color=#" + colorHexString + ">" + text + "</color>");
			}
			return string.Join(", ", list);
		}

		public static void DonationThanks(CharacterBody donor, Dictionary<PickupIndex, int> pickupIndexes, int tier)
		{
			switch (ModConfig.NewtDialogue.Value)
			{
			case ShopKeeper.Dialogue.BazaarIsMyHome:
			{
				object obj = tier switch
				{
					1 => LanguageAPI.NEWT_DONATE_LIST1, 
					2 => LanguageAPI.NEWT_DONATE_LIST2, 
					3 => LanguageAPI.NEWT_DONATE_LIST3, 
					_ => LanguageAPI.NEWT_DONATE_LIST_CHARACTER, 
				};
				PlayerCharacterMasterController playerCharacterMasterController = (Object.op_Implicit((Object)(object)donor.master) ? donor.master.playerCharacterMasterController : null);
				Send(Language.GetStringFormatted((string)obj, new object[4]
				{
					NewtName,
					GetDeathState(),
					GetColoredPlayerName(playerCharacterMasterController),
					GetItemNames(pickupIndexes)
				}));
				break;
			}
			case ShopKeeper.Dialogue.Default:
				NewtSays(RandomToken(LanguageAPI.NEWT_UPGRADE));
				AnnouncePickups(donor, pickupIndexes);
				break;
			default:
				AnnouncePickups(donor, pickupIndexes);
				break;
			}
		}

		private static void AnnouncePickups(CharacterBody body, Dictionary<PickupIndex, int> pickupIndexes)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			foreach (KeyValuePair<PickupIndex, int> pickupIndex in pickupIndexes)
			{
				pickupIndex.Deconstruct(out var key, out var value);
				PickupIndex val = key;
				int num = value;
				PickupDef pickupDef = PickupCatalog.GetPickupDef(val);
				if (num > 0 && pickupDef != null)
				{
					Chat.SendBroadcastChat((ChatMessageBase)new PlayerPickupChatMessage
					{
						subjectAsCharacterBody = body,
						baseToken = "PLAYER_PICKUP",
						pickupToken = pickupDef.nameToken,
						pickupColor = Color32.op_Implicit(pickupDef.baseColor),
						pickupQuantity = (uint)num
					});
				}
			}
		}

		public static void WelcomeWord()
		{
			switch (ModConfig.NewtDialogue.Value)
			{
			case ShopKeeper.Dialogue.BazaarIsMyHome:
			{
				int num = Random.Next(LanguageAPI.NEWT_WELCOME_WORD.Length);
				if (!ShopKeeper.DiedAtLeastOnce)
				{
					Send(Language.GetStringFormatted(LanguageAPI.NEWT_WELCOME_WORD[num], new object[1] { NewtName }));
				}
				else
				{
					Send(Language.GetStringFormatted(LanguageAPI.NEWT_ANGRY_WELCOME_WORD[num], new object[2]
					{
						NewtName,
						GetDeathState()
					}));
				}
				break;
			}
			case ShopKeeper.Dialogue.Default:
				NewtSays(Language.GetString(RandomToken(ShopKeeper.DiedAtLeastOnce ? LanguageAPI.NEWT_ANGRY_WELCOME : LanguageAPI.NEWT_WELCOME)));
				break;
			}
		}

		public static void ShowNewtDeath()
		{
			Send(Language.GetStringFormatted(LanguageAPI.NEWT_DEATH_INFO, new object[2]
			{
				NewtName,
				GetDeathState()
			}));
		}

		public static void HitWord()
		{
			switch (ModConfig.NewtDialogue.Value)
			{
			case ShopKeeper.Dialogue.BazaarIsMyHome:
				Send(Language.GetStringFormatted(RandomToken(LanguageAPI.NEWT_ATTACKED_WORD), new object[2]
				{
					NewtName,
					GetDeathState()
				}));
				break;
			case ShopKeeper.Dialogue.Default:
				NewtSays(RandomToken(LanguageAPI.NEWT_ANNOY));
				break;
			}
		}

		public static void LunarPurchase()
		{
			if (ModConfig.NewtDialogue.Value == ShopKeeper.Dialogue.Default && Random.NextDouble() < 0.2)
			{
				NewtSays(RandomToken(LanguageAPI.NEWT_LUNAR_PURCHASE));
			}
		}

		private static string RandomToken(string[] tokens)
		{
			return tokens[Random.Next(tokens.Length)];
		}

		private static void NewtSays(string token)
		{
			//IL_000d: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			if (Object.op_Implicit((Object)(object)ShopKeeper.Body))
			{
				Chat.SendBroadcastChat((ChatMessageBase)new BodyChatMessage
				{
					bodyObject = ((Component)ShopKeeper.Body).gameObject,
					token = token
				});
			}
		}

		public static void Send(string message)
		{
			//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: Expected O, but got Unknown
			Chat.SendBroadcastChat((ChatMessageBase)new SimpleChatMessage
			{
				baseToken = message
			});
		}
	}
	public class DonationRewardDisplay : MonoBehaviour
	{
		private const string BudObjectName = "DonationRewardBud";

		private const float CycleInterval = 2f;

		private const float BudHeight = 0.4636f;

		private const float BudSpacing = 0.3f;

		private static readonly Vector3[] BudOffsets = (Vector3[])(object)new Vector3[5]
		{
			new Vector3(0f, 0f, 0f),
			new Vector3(0f, 0f, 0.3f),
			new Vector3(0f, 0f, -0.3f),
			new Vector3(0.3f, 0f, 0f),
			new Vector3(-0.3f, 0f, 0f)
		};

		private static readonly int[][] BudsForRewardSize = new int[6][]
		{
			new int[0],
			new int[1],
			new int[2] { 1, 2 },
			new int[3] { 0, 1, 2 },
			new int[4] { 1, 2, 3, 4 },
			new int[5] { 0, 1, 2, 3, 4 }
		};

		private static AsyncOperationHandle<GameObject> budPrefab;

		private readonly List<InstancedPurchase> buds = new List<InstancedPurchase>();

		private Func<PlayerCharacterMasterController, Dictionary<PickupIndex, int>> rollReward;

		private float nextCycleTime;

		private static UniquePickup EmptyOpenBud => new UniquePickup(new PickupIndex(PickupCatalog.pickupCount));

		public static void Preload()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			budPrefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/LunarShopTerminal/LunarShopTerminal.prefab");
		}

		public static void Apply(GameObject altar, Func<PlayerCharacterMasterController, Dictionary<PickupIndex, int>> rollReward)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			DonationRewardDisplay donationRewardDisplay = altar.AddComponent<DonationRewardDisplay>();
			donationRewardDisplay.rollReward = rollReward;
			donationRewardDisplay.SpawnBuds(altar.transform.position);
		}

		private void SpawnBuds(Vector3 displayPosition)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			if (ModCompatibilityQoLChests.enabled)
			{
				ModCompatibilityQoLChests.RegisterQoLChestsBlacklist("DonationRewardBud");
			}
			Quaternion val = Quaternion.Euler(0f, ((Component)this).transform.eulerAngles.y, 0f);
			Vector3 val2 = displayPosition + Vector3.up * 0.4636f;
			List<GameObject> list = new List<GameObject>();
			Vector3[] budOffsets = BudOffsets;
			foreach (Vector3 val3 in budOffsets)
			{
				Vector3 val4 = val * val3;
				Quaternion val5 = ((val4 == Vector3.zero) ? val : Quaternion.LookRotation(val4));
				GameObject val6 = Object.Instantiate<GameObject>(budPrefab.WaitForCompletion(), val2 + val4, val5);
				((Object)val6).name = "DonationRewardBud";
				val6.transform.localScale = Vector3.one;
				val6.GetComponent<PurchaseInteraction>().available = false;
				val6.GetComponent<ShopTerminalBehavior>().selfGeneratePickup = false;
				buds.Add(val6.AddComponent<InstancedPurchase>());
				NetworkServer.Spawn(val6);
				list.Add(val6);
			}
			LunarBudScaleSync.Apply(list);
		}

		private void Update()
		{
			if (!NetworkServer.active || rollReward == null)
			{
				return;
			}
			float unscaledTime = Time.unscaledTime;
			if (unscaledTime < nextCycleTime)
			{
				return;
			}
			nextCycleTime = unscaledTime + 2f;
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				if (Object.op_Implicit((Object)(object)instance))
				{
					ShowNextReward(instance);
				}
			}
		}

		public void ShowNextReward(PlayerCharacterMasterController pc)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<PickupIndex, int> dictionary = rollReward(pc);
			List<PickupIndex> list = new List<PickupIndex>();
			if (dictionary != null)
			{
				foreach (KeyValuePair<PickupIndex, int> item in dictionary)
				{
					for (int i = 0; i < item.Value; i++)
					{
						if (list.Count >= buds.Count)
						{
							break;
						}
						list.Add(item.Key);
					}
				}
			}
			int[] array = BudsForRewardSize[Math.Min(list.Count, BudsForRewardSize.Length - 1)];
			UniquePickup val = ((list.Count > 0) ? EmptyOpenBud : UniquePickup.none);
			for (int j = 0; j < buds.Count; j++)
			{
				if (Object.op_Implicit((Object)(object)buds[j]))
				{
					InstancedPurchaseStruct orCreate = buds[j].GetOrCreate(pc);
					int num = Array.IndexOf(array, j);
					UniquePickup val2 = (UniquePickup)((num >= 0 && num < list.Count) ? new UniquePickup(list[num]) : val);
					if (!((UniquePickup)(ref orCreate.pickup)).Equals(val2))
					{
						orCreate.pickup = val2;
						InstancedPurchases.UpdatePlayer(((Component)buds[j]).gameObject, pc);
					}
				}
			}
		}
	}
	public class FreeSwaps : MonoBehaviour
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_PayCost_PayCostContext_PayCostResults <0>__CostTypeDef_PayCost;

			public static hook_CanBeAffordedByInteractor <1>__PurchaseInteraction_CanBeAffordedByInteractor;

			public static hook_UpdateHologramContent <2>__PurchaseInteraction_UpdateHologramContent;
		}

		private static PurchaseInteraction freePurchase;

		private readonly HashSet<PlayerCharacterMasterController> owners = new HashSet<PlayerCharacterMasterController>();

		public static void Hook()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0030: 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_003b: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			object obj = <>O.<0>__CostTypeDef_PayCost;
			if (obj == null)
			{
				hook_PayCost_PayCostContext_PayCostResults val = CostTypeDef_PayCost;
				<>O.<0>__CostTypeDef_PayCost = val;
				obj = (object)val;
			}
			CostTypeDef.PayCost_PayCostContext_PayCostResults += (hook_PayCost_PayCostContext_PayCostResults)obj;
			object obj2 = <>O.<1>__PurchaseInteraction_CanBeAffordedByInteractor;
			if (obj2 == null)
			{
				hook_CanBeAffordedByInteractor val2 = PurchaseInteraction_CanBeAffordedByInteractor;
				<>O.<1>__PurchaseInteraction_CanBeAffordedByInteractor = val2;
				obj2 = (object)val2;
			}
			PurchaseInteraction.CanBeAffordedByInteractor += (hook_CanBeAffordedByInteractor)obj2;
			object obj3 = <>O.<2>__PurchaseInteraction_UpdateHologramContent;
			if (obj3 == null)
			{
				hook_UpdateHologramContent val3 = PurchaseInteraction_UpdateHologramContent;
				<>O.<2>__PurchaseInteraction_UpdateHologramContent = val3;
				obj3 = (object)val3;
			}
			PurchaseInteraction.UpdateHologramContent += (hook_UpdateHologramContent)obj3;
		}

		public static void BuySlot(GameObject slot, PlayerCharacterMasterController buyer)
		{
			if (Object.op_Implicit((Object)(object)slot) && Object.op_Implicit((Object)(object)buyer))
			{
				FreeSwaps freeSwaps = default(FreeSwaps);
				if (!slot.TryGetComponent<FreeSwaps>(ref freeSwaps))
				{
					freeSwaps = slot.AddComponent<FreeSwaps>();
				}
				freeSwaps.owners.Add(buyer);
			}
		}

		public static bool IsFreeFor(Component slot, PlayerCharacterMasterController player)
		{
			FreeSwaps freeSwaps = default(FreeSwaps);
			if (Object.op_Implicit((Object)(object)slot) && Object.op_Implicit((Object)(object)player) && slot.TryGetComponent<FreeSwaps>(ref freeSwaps))
			{
				return freeSwaps.owners.Contains(player);
			}
			return false;
		}

		public static T RunFree<T>(PurchaseInteraction purchase, Func<T> purchaseAction)
		{
			PurchaseInteraction val = freePurchase;
			int cost = purchase.cost;
			purchase.cost = 0;
			freePurchase = purchase;
			try
			{
				return purchaseAction();
			}
			finally
			{
				purchase.cost = cost;
				freePurchase = val;
			}
		}

		private static bool PurchaseInteraction_CanBeAffordedByInteractor(orig_CanBeAffordedByInteractor orig, PurchaseInteraction self, Interactor activator)
		{
			CharacterBody val = (Object.op_Implicit((Object)(object)activator) ? ((Component)activator).GetComponent<CharacterBody>() : null);
			if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.master) && IsFreeFor((Component)(object)self, val.master.playerCharacterMasterController))
			{
				return true;
			}
			return orig.Invoke(self, activator);
		}

		private static void CostTypeDef_PayCost(orig_PayCost_PayCostContext_PayCostResults orig, CostTypeDef self, PayCostContext context, PayCostResults result)
		{
			if (!Object.op_Implicit((Object)(object)freePurchase) || !((Object)(object)context.purchaseInteraction == (Object)(object)freePurchase))
			{
				orig.Invoke(self, context, result);
			}
		}

		private static void PurchaseInteraction_UpdateHologramContent(orig_UpdateHologramContent orig, PurchaseInteraction self, GameObject hologramContentObject, Transform viewer)
		{
			orig.Invoke(self, hologramContentObject, viewer);
			CostHologramContent val = default(CostHologramContent);
			if (Object.op_Implicit((Object)(object)((Component)self).GetComponent<InstancedPurchase>()) && IsFreeFor((Component)(object)self, Helper.GetHostPlayer()) && hologramContentObject.TryGetComponent<CostHologramContent>(ref val))
			{
				val.displayValue = 0;
			}
		}
	}
	public class LunarBudScaleSync : MonoBehaviour
	{
		private static AsyncOperationHandle<GameObject> helperPrefab;

		private static bool helperUnavailable;

		private readonly List<NetworkIdentity> buds = new List<NetworkIdentity>();

		private readonly HashSet<NetworkConnection> synchronizedClients = new HashSet<NetworkConnection>();

		public static void Preload()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			helperPrefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC3/Drifter/DrifterHoard.prefab");
		}

		public static void Apply(List<GameObject> budObjects)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			if (!NetworkServer.active || budObjects.Count == 0 || helperUnavailable)
			{
				return;
			}
			GameObject val = new GameObject("LunarBudScaleSync");
			SceneManager.MoveGameObjectToScene(val, budObjects[0].scene);
			LunarBudScaleSync lunarBudScaleSync = val.AddComponent<LunarBudScaleSync>();
			foreach (GameObject budObject in budObjects)
			{
				lunarBudScaleSync.buds.Add(budObject.GetComponent<NetworkIdentity>());
			}
			((MonoBehaviour)lunarBudScaleSync).StartCoroutine(lunarBudScaleSync.SynchronizeClients());
		}

		private IEnumerator SynchronizeClients()
		{
			WaitForSecondsRealtime retryDelay = new WaitForSecondsRealtime(1f);
			while (NetworkServer.active)
			{
				buds.RemoveAll((NetworkIdentity bud) => !Object.op_Implicit((Object)(object)bud));
				if (buds.Count == 0)
				{
					break;
				}
				synchronizedClients.RemoveWhere((NetworkConnection connection) => !connection.isReady || !NetworkServer.connections.Contains(connection));
				List<NetworkConnection> pendingClients = GetPendingClients();
				bool flag = true;
				if (pendingClients.Count > 0)
				{
					try
					{
						flag = SendScaleFix(pendingClients);
					}
					catch (Exception arg)
					{
						helperUnavailable = true;
						Log.LogError($"Could not fix bud scale for clients: {arg}");
						break;
					}
				}
				yield return flag ? null : retryDelay;
			}
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		private List<NetworkConnection> GetPendingClients()
		{
			List<NetworkConnection> list = new List<NetworkConnection>();
			foreach (NetworkConnection connection in NetworkServer.connections)
			{
				if (connection != null && connection.isReady && !Util.ConnectionIsLocal(connection) && !synchronizedClients.Contains(connection) && buds.All((NetworkIdentity bud) => bud.observers != null && bud.observers.Contains(connection)))
				{
					list.Add(connection);
				}
			}
			return list;
		}

		private bool SendScaleFix(List<NetworkConnection> clients)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = helperPrefab.WaitForCompletion();
			ItemShareController val2 = (Object.op_Implicit((Object)(object)val) ? val.GetComponent<ItemShareController>() : null);
			if (!Object.op_Implicit((Object)(object)val2) || Object.op_Implicit((Object)(object)val2.pickupMuzzle) || !string.IsNullOrEmpty(val2.pickupMuzzleChildName) || val2.subsequentPickupLocalOffset != Vector3.zero)
			{
				throw new InvalidOperationException("The Drifter hoard no longer has the expected settings.");
			}
			GameObject val3 = Object.Instantiate<GameObject>(val, new Vector3(0f, 10000f, 0f), Quaternion.identity);
			bool result = true;
			try
			{
				val3.GetComponent<EntityStateMachine>().SetState((EntityState)new Idle());
				val3.GetComponent<BuffWard>().Networkradius = 0f;
				NetworkServer.Spawn(val3);
				NetworkIdentity component = val3.GetComponent<NetworkIdentity>();
				foreach (NetworkConnection client in clients)
				{
					bool flag = true;
					foreach (NetworkIdentity bud in buds)
					{
						byte[] array = InstancedPurchases.CreatePickupDisplayRefresh(bud, client, QosChannelIndex.defaultReliable.intVal);
						if (array == null)
						{
							flag = false;
							continue;
						}
						byte[] array2 = CreateScaleFixMessages(component.netId, bud, array);
						flag = client.SendBytes(array2, array2.Length, QosChannelIndex.defaultReliable.intVal) && flag;
					}
					if (flag)
					{
						synchronizedClients.Add(client);
					}
					else
					{
						result = false;
					}
				}
				return result;
			}
			finally
			{
				NetworkServer.Destroy(val3);
			}
		}

		private static byte[] CreateScaleFixMessages(NetworkInstanceId helperId, NetworkIdentity bud, byte[] displayRefresh)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0019: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			NetworkWriter val = new NetworkWriter();
			val.StartMessage((short)2);
			val.WritePackedUInt32((uint)ItemShareController.kRpcRpcParentToMuzzle);
			val.Write(helperId);
			val.Write(bud.netId);
			val.FinishMessage();
			NetworkWriter val2 = new NetworkWriter();
			val2.StartMessage((short)68);
			((MessageBase)new TeleportMessage
			{
				gameObject = ((Component)bud).gameObject,
				newPosition = ((Component)bud).transform.position,
				newRotation = ((Component)bud).transform.rotation,
				useRotation = true,
				delta = ((Component)bud).transform.position
			}).Serialize(val2);
			val2.FinishMessage();
			NetworkWriter val3 = new NetworkWriter();
			byte[] array = val.ToArray();
			byte[] array2 = val2.ToArray();
			val3.Write(array, array.Length);
			val3.Write(array2, array2.Length);
			val3.Write(displayRefresh, displayRefresh.Length);
			return val3.ToArray();
		}
	}
	public class PriceSigns : MonoBehaviour
	{
		private class Sign
		{
			public GameObject terminal;

			public NetworkIdentity seer;

			public Vector3 clientPosition;

			public Quaternion clientRotation;

			public readonly HashSet<NetworkConnection> synchronizedClients = new HashSet<NetworkConnection>();

			public readonly HashSet<PlayerCharacterMasterController> hiddenFor = new HashSet<PlayerCharacterMasterController>();

			public readonly HashSet<NetworkConnection> hiddenClients = new HashSet<NetworkConnection>();
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static hook_ShouldDisplayHologram <0>__PurchaseInteraction_ShouldDisplayHologram;
		}

		private static readonly Vector3 SetupPosition = new Vector3(0f, 10000f, 0f);

		private static AsyncOperationHandle<GameObject> seerPrefab;

		private static bool signsUnavailable;

		private static readonly List<PriceSigns> instances = new List<PriceSigns>();

		private readonly List<Sign> signs = new List<Sign>();

		public static void Preload()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (!seerPrefab.IsValid())
			{
				seerPrefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/bazaar/SeerStation.prefab");
			}
		}

		public static void Hook()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__PurchaseInteraction_ShouldDisplayHologram;
			if (obj == null)
			{
				hook_ShouldDisplayHologram val = PurchaseInteraction_ShouldDisplayHologram;
				<>O.<0>__PurchaseInteraction_ShouldDisplayHologram = val;
				obj = (object)val;
			}
			PurchaseInteraction.ShouldDisplayHologram += (hook_ShouldDisplayHologram)obj;
		}

		private void Awake()
		{
			instances.Add(this);
		}

		private void OnDestroy()
		{
			instances.Remove(this);
		}

		public static void HideFor(GameObject terminal, PlayerCharacterMasterController player)
		{
			if (!NetworkServer.active || !Object.op_Implicit((Object)(object)terminal) || !Object.op_Implicit((Object)(object)player))
			{
				return;
			}
			foreach (PriceSigns instance in instances)
			{
				foreach (Sign sign in instance.signs)
				{
					if ((Object)(object)sign.terminal == (Object)(object)terminal && sign.hiddenFor.Add(player))
					{
						NetworkConnection val = (Object.op_Implicit((Object)(object)player.networkUser) ? ((NetworkBehaviour)player.networkUser).connectionToClient : null);
						if (val != null && !Util.ConnectionIsLocal(val))
						{
							TryHideFromClient(sign, val);
						}
					}
				}
			}
		}

		private static bool PurchaseInteraction_ShouldDisplayHologram(orig_ShouldDisplayHologram orig, PurchaseInteraction self, GameObject viewer)
		{
			PlayerCharacterMasterController val = ((instances.Count > 0 && NetworkServer.active) ? Helper.GetHostPlayer() : null);
			if (Object.op_Implicit((Object)(object)val))
			{
				foreach (PriceSigns instance in instances)
				{
					foreach (Sign sign in instance.signs)
					{
						if (Object.op_Implicit((Object)(object)sign.seer) && (Object)(object)((Component)sign.seer).gameObject == (Object)(object)((Component)self).gameObject && sign.hiddenFor.Contains(val))
						{
							return false;
						}
					}
				}
			}
			return orig.Invoke(self, viewer);
		}

		private static PlayerCharacterMasterController GetPlayer(NetworkConnection connection)
		{
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				if (Object.op_Implicit((Object)(object)instance) && Object.op_Implicit((Object)(object)instance.networkUser) && ((NetworkBehaviour)instance.networkUser).connectionToClient == connection)
				{
					return instance;
				}
			}
			return null;
		}

		private static bool TryHideFromClient(Sign sign, NetworkConnection connection)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (sign.hiddenClients.Contains(connection))
			{
				return true;
			}
			if (!Object.op_Implicit((Object)(object)sign.seer) || sign.seer.observers == null || !sign.seer.observers.Contains(connection))
			{
				return false;
			}
			NetworkWriter val = new NetworkWriter();
			val.StartMessage((short)1);
			val.Write(sign.seer.netId);
			val.FinishMessage();
			if (!connection.SendWriter(val, QosChannelIndex.defaultReliable.intVal))
			{
				return false;
			}
			sign.hiddenClients.Add(connection);
			return true;
		}

		public static void Apply(List<GameObject> terminals, int cost, CostTypeIndex costType, float signHeight)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Apply(terminals.Select((GameObject terminal) => (terminal: terminal, terminal.transform.position + Vector3.up * signHeight, terminal.transform.rotation * Quaternion.Euler(0f, 180f, 0f))).ToList(), cost, costType);
		}

		public static void Apply(GameObject terminal, Vector3 signPosition, Quaternion signRotation, int cost, CostTypeIndex costType)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Apply(new List<(GameObject, Vector3, Quaternion)> { (terminal, signPosition, signRotation) }, cost, costType);
		}

		private static void Apply(List<(GameObject terminal, Vector3 position, Quaternion rotation)> placements, int cost, CostTypeIndex costType)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active || placements.Count == 0 || cost <= 0 || signsUnavailable)
			{
				return;
			}
			GameObject val = new GameObject("PriceSigns");
			SceneManager.MoveGameObjectToScene(val, placements[0].terminal.scene);
			PriceSigns priceSigns = val.AddComponent<PriceSigns>();
			try
			{
				foreach (var (terminal, signPosition, signRotation) in placements)
				{
					priceSigns.signs.Add(CreateSign(terminal, signPosition, signRotation, cost, costType));
				}
			}
			catch (Exception arg)
			{
				signsUnavailable = true;
				Log.LogError($"Could not create price signs: {arg}");
				foreach (Sign sign in priceSigns.signs)
				{
					NetworkServer.Destroy(((Component)sign.seer).gameObject);
				}
				Object.Destroy((Object)(object)val);
				return;
			}
			((MonoBehaviour)priceSigns).StartCoroutine(priceSigns.SynchronizeClients());
		}

		private static Sign CreateSign(GameObject terminal, Vector3 signPosition, Quaternion signRotation, int cost, CostTypeIndex costType)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Invalid comparison between Unknown and I4
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Invalid comparison between Unknown and I4
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(seerPrefab.WaitForCompletion(), SetupPosition, Quaternion.identity);
			SceneManager.MoveGameObjectToScene(val, terminal.scene);
			try
			{
				ModelLocator component = val.GetComponent<ModelLocator>();
				HologramProjector component2 = val.GetComponent<HologramProjector>();
				NetworkStateMachine component3 = val.GetComponent<NetworkStateMachine>();
				EntityStateMachine component4 = val.GetComponent<EntityStateMachine>();
				PurchaseInteraction component5 = val.GetComponent<PurchaseInteraction>();
				if (!Object.op_Implicit((Object)(object)component) || !Object.op_Implicit((Object)(object)component.modelTransform) || Object.op_Implicit((Object)(object)component.modelBaseTransform) || (Object)(object)component.modelTransform.parent != (Object)(object)val.transform || !Object.op_Implicit((Object)(object)component2) || !Object.op_Implicit((Object)(object)component2.hologramPivot) || (Object)(object)component2.hologramPivot.parent != (Object)(object)val.transform || !component2.disableHologramRotation || !Object.op_Implicit((Object)(object)component3) || !Object.op_Implicit((Object)(object)component4) || component3.stateMachines.Length != 1 || (Object)(object)component3.stateMachines[0] != (Object)(object)component4 || !Object.op_Implicit((Object)(object)component5))
				{
					throw new InvalidOperationException("The Lunar Seer no longer has the expected price sign.");
				}
				if ((int)EntityStateCatalog.GetStateIndex(typeof(DeathState)) == -1 || (int)EntityStateCatalog.GetStateIndex(typeof(Idle)) == -1)
				{
					throw new InvalidOperationException("The states the price signs need are missing.");
				}
				((Object)val).name = "PriceSign";
				component5.Networkcost = cost;
				component5.NetworkcostType = costType;
				Transform hologramPivot = component2.hologramPivot;
				Sign sign = new Sign
				{
					terminal = terminal,
					seer = val.GetComponent<NetworkIdentity>()
				};
				sign.clientRotation = signRotation * Quaternion.Inverse(hologramPivot.localRotation);
				sign.clientPosition = signPosition - sign.clientRotation * hologramPivot.localPosition;
				NetworkServer.Spawn(val);
				hologramPivot.SetPositionAndRotation(signPosition, signRotation);
				return sign;
			}
			catch
			{
				NetworkServer.Destroy(val);
				throw;
			}
		}

		private IEnumerator SynchronizeClients()
		{
			WaitForSecondsRealtime interval = new WaitForSecondsRealtime(1f);
			while (NetworkServer.active)
			{
				for (int num = signs.Count - 1; num >= 0; num--)
				{
					Sign sign = signs[num];
					if (!Object.op_Implicit((Object)(object)sign.seer) || !CanStillBeBought(sign.terminal))
					{
						if (Object.op_Implicit((Object)(object)sign.seer))
						{
							NetworkServer.Destroy(((Component)sign.seer).gameObject);
						}
						signs.RemoveAt(num);
					}
					else
					{
						sign.synchronizedClients.RemoveWhere((NetworkConnection connection) => !connection.isReady || !NetworkServer.connections.Contains(connection));
						sign.hiddenClients.RemoveWhere((NetworkConnection connection) => !connection.isReady || !NetworkServer.connections.Contains(connection));
						foreach (NetworkConnection connection in NetworkServer.connections)
						{
							if (connection != null && connection.isReady && !Util.ConnectionIsLocal(connection))
							{
								if (sign.hiddenFor.Count > 0 && sign.hiddenFor.Contains(GetPlayer(connection)))
								{
									TryHideFromClient(sign, connection);
								}
								else if (!sign.synchronizedClients.Contains(connection) && sign.seer.observers != null && sign.seer.observers.Contains(connection) && SendSetup(sign, connection))
								{
									sign.synchronizedClients.Add(connection);
								}
							}
						}
					}
				}
				if (signs.Count == 0)
				{
					break;
				}
				yield return interval;
			}
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		private static bool CanStillBeBought(GameObject terminal)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Invalid comparison between Unknown and I4
			if (!Object.op_Implicit((Object)(object)terminal))
			{
				return false;
			}
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			if (terminal.TryGetComponent<InstancedPurchase>(ref instancedPurchase))
			{
				foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
				{
					if (instancedPurchase.GetOrOriginal(instance).available)
					{
						return true;
					}
				}
				return false;
			}
			GenericInteraction val = default(GenericInteraction);
			if (terminal.TryGetComponent<GenericInteraction>(ref val))
			{
				return (int)val.interactability > 0;
			}
			DroneVendorMultiShopController val2 = default(DroneVendorMultiShopController);
			if (terminal.TryGetComponent<DroneVendorMultiShopController>(ref val2))
			{
				if (val2._terminals != null)
				{
					return val2._terminals.Any((DroneVendorTerminalBehavior droneTerminal) => Object.op_Implicit((Object)(object)droneTerminal) && Object.op_Implicit((Object)(object)droneTerminal.purchaseInteraction) && (droneTerminal.purchaseInteraction.available || (!droneTerminal.GetHasBeenPurchased() && droneTerminal.CurrentPickupIndex != PickupIndex.none)));
				}
				return false;
			}
			PurchaseInteraction component = terminal.GetComponent<PurchaseInteraction>();
			if (Object.op_Implicit((Object)(object)component) && component.available)
			{
				return component.cost > 0;
			}
			return false;
		}

		private static bool SendSetup(Sign sign, NetworkConnection connection)
		{
			//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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_001b: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0031: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			NetworkWriter val = new NetworkWriter();
			WriteState(val, sign.seer.netId, (EntityState)new DeathState());
			WriteState(val, sign.seer.netId, (EntityState)new Idle());
			NetworkWriter val2 = new NetworkWriter();
			val2.StartMessage((short)68);
			((MessageBase)new TeleportMessage
			{
				gameObject = ((Component)sign.seer).gameObject,
				newPosition = sign.clientPosition,
				newRotation = sign.clientRotation,
				useRotation = true,
				delta = sign.clientPosition - SetupPosition
			}).Serialize(val2);
			val2.FinishMessage();
			byte[] array = val2.ToArray();
			val.Write(array, array.Length);
			byte[] array2 = val.ToArray();
			return connection.SendBytes(array2, array2.Length, QosChannelIndex.defaultReliable.intVal);
		}

		private static void WriteState(NetworkWriter writer, NetworkInstanceId seerId, EntityState state)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			NetworkWriter val = new NetworkWriter();
			val.StartMessage((short)48);
			val.Write(seerId);
			val.Write((byte)0);
			NetworkExtensions.Write(val, EntityStateCatalog.GetStateIndex(((object)state).GetType()));
			state.OnSerialize(val);
			val.FinishMessage();
			byte[] array = val.ToArray();
			writer.Write(array, array.Length);
		}
	}
	public class VoidSignalBeam : MonoBehaviour
	{
		private const string BeamChildName = "IdleFX";

		private const float ClientDelay = 2f;

		private readonly Dictionary<NetworkConnection, float> observedSince = new Dictionary<NetworkConnection, float>();

		private readonly HashSet<NetworkConnection> beamRemoved = new HashSet<NetworkConnection>();

		public static void Remove(GameObject signal)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			if (NetworkServer.active && (int)EntityStateCatalog.GetStateIndex(typeof(Idle)) != -1)
			{
				signal.AddComponent<VoidSignalBeam>();
			}
		}

		private IEnumerator Start()
		{
			NetworkIdentity identity = ((Component)this).GetComponent<NetworkIdentity>();
			NetworkStateMachine networkStateMachine = ((Component)this).GetComponent<NetworkStateMachine>();
			WaitForSecondsRealtime interval = new WaitForSecondsRealtime(0.5f);
			while (NetworkServer.active && Object.op_Implicit((Object)(object)identity) && Object.op_Implicit((Object)(object)networkStateMachine))
			{
				HideLocalBeam();
				beamRemoved.RemoveWhere((NetworkConnection connection) => !connection.isReady || !NetworkServer.connections.Contains(connection));
				foreach (NetworkConnection connection in NetworkServer.connections)
				{
					if (connection != null && connection.isReady && !Util.ConnectionIsLocal(connection) && !beamRemoved.Contains(connection))
					{
						float value;
						if (identity.observers == null || !identity.observers.Contains(connection))
						{
							observedSince.Remove(connection);
						}
						else if (!observedSince.TryGetValue(connection, out value))
						{
							observedSince[connection] = Time.unscaledTime;
						}
						else if (Time.unscaledTime - value >= 2f && SendIdle(identity, networkStateMachine, connection))
						{
							beamRemoved.Add(connection);
						}
					}
				}
				yield return interval;
			}
		}

		private void HideLocalBeam()
		{
			ModelLocator component = ((Component)this).GetComponent<ModelLocator>();
			ChildLocator val = ((Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component.modelTransform)) ? ((Component)component.modelTransform).GetComponent<ChildLocator>() : null);
			GameObject val2 = (Object.op_Implicit((Object)(object)val) ? val.FindChildGameObject("IdleFX") : null);
			if (Object.op_Implicit((Object)(object)val2) && val2.activeSelf)
			{
				val2.SetActive(false);
			}
		}

		private static bool SendIdle(NetworkIdentity identity, NetworkStateMachine networkStateMachine, NetworkConnection connection)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Idle val = new Idle();
			NetworkWriter val2 = new NetworkWriter();
			val2.StartMessage((short)48);
			val2.Write(identity);
			val2.Write((byte)0);
			NetworkExtensions.Write(val2, EntityStateCatalog.GetStateIndex(((object)val).GetType()));
			((EntityState)val).OnSerialize(val2);
			val2.FinishMessage();
			return connection.SendWriter(val2, ((NetworkBehaviour)networkStateMachine).GetNetworkChannel());
		}
	}
	public class InstancedPurchase : MonoBehaviour
	{
		public readonly InstancedPurchaseStruct original = new InstancedPurchaseStruct();

		public Dictionary<PlayerCharacterMasterController, InstancedPurchaseStruct> purchases = new Dictionary<PlayerCharacterMasterController, InstancedPurchaseStruct>();

		public PlayerCharacterMasterController pcClient;

		public int lunarShopIndex = -1;

		private readonly HashSet<PlayerCharacterMasterController> pendingUpdates = new HashSet<PlayerCharacterMasterController>();

		private readonly Dictionary<PlayerCharacterMasterController, NetworkConnection> initializedClients = new Dictionary<PlayerCharacterMasterController, NetworkConnection>();

		private float nextRetryTime;

		public InstancedPurchaseStruct GetOrCreate(PlayerCharacterMasterController pc)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)pc))
			{
				return original;
			}
			if (!purchases.TryGetValue(pc, out var value))
			{
				value = new InstancedPurchaseStruct
				{
					available = original.available,
					pickup = original.pickup,
					hasBeenPurchased = original.hasBeenPurchased,
					hidden = original.hidden,
					hasBeenPurchasedOnce = original.hasBeenPurchasedOnce
				};
				if (IsShopDisabledFor(pc))
				{
					value.available = false;
					value.pickup = UniquePickup.none;
					value.hasBeenPurchased = true;
				}
				purchases.Add(pc, value);
			}
			return value;
		}

		private bool IsShopDisabledFor(PlayerCharacterMasterController pc)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (lunarShopIndex < 0 || !Object.op_Implicit((Object)(object)pc.master) || !Object.op_Implicit((Object)(object)pc.master.bodyPrefab))
			{
				return false;
			}
			BodyIndex key = BodyCatalog.FindBodyIndex(pc.master.bodyPrefab);
			if (!ModConfig.LunarShopAmountDependingOnCharacterParsed.TryGetValue(key, out var value))
			{
				return false;
			}
			if (value >= 0)
			{
				return lunarShopIndex >= value;
			}
			return false;
		}

		public InstancedPurchaseStruct GetOrOriginal(PlayerCharacterMasterController pc)
		{
			if (Object.op_Implicit((Object)(object)pc) && !purchases.ContainsKey(pc) && IsShopDisabledFor(pc))
			{
				return GetOrCreate(pc);
			}
			if (!Object.op_Implicit((Object)(object)pc) || !purchases.TryGetValue(pc, out var value))
			{
				return original;
			}
			return value;
		}

		public void QueueUpdate(PlayerCharacterMasterController pc)
		{
			if (Object.op_Implicit((Object)(object)pc))
			{
				pendingUpdates.Add(pc);
			}
		}

		private void LateUpdate()
		{
			if (!NetworkServer.active || Time.unscaledTime < nextRetryTime)
			{
				return;
			}
			NetworkIdentity component = ((Component)this).GetComponent<NetworkIdentity>();
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				if (!Object.op_Implicit((Object)(object)instance) || ((NetworkBehaviour)instance).hasAuthority)
				{
					continue;
				}
				NetworkConnection val = (Object.op_Implicit((Object)(object)instance.networkUser) ? ((NetworkBehaviour)instance.networkUser).connectionToClient : null);
				NetworkConnection value;
				if (val == null || !val.isReady || !Object.op_Implicit((Object)(object)component) || component.observers == null || !component.observers.Contains(val))
				{
					initializedClients.Remove(instance);
				}
				else if (!initializedClients.TryGetValue(instance, out value) || value != val || pendingUpdates.Contains(instance))
				{
					if (!InstancedPurchases.SendUpdateToClient(this, instance))
					{
						nextRetryTime = Time.unscaledTime + 1f;
						break;
					}
					initializedClients[instance] = val;
					pendingUpdates.Remove(instance);
				}
			}
		}
	}
	public class InstancedPurchaseStruct
	{
		public bool available;

		public UniquePickup pickup = UniquePickup.none;

		public bool hasBeenPurchased;

		public bool hidden;

		public bool hasBeenPurchasedOnce;

		public bool CanReroll
		{
			get
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				if (available && !hasBeenPurchased && !hasBeenPurchasedOnce)
				{
					return !((UniquePickup)(ref pickup)).Equals(UniquePickup.none);
				}
				return false;
			}
		}
	}
	public class InstancedPurchases
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_OnSerialize <0>__PurchaseInteraction_OnSerialize;

			public static hook_OnSerialize <1>__ShopTerminalBehavior_OnSerialize;

			public static hook_SetPickup <2>__ShopTerminalBehavior_SetPickup;

			public static hook_SetAvailable <3>__PurchaseInteraction_SetAvailable;

			public static hook_SetHasBeenPurchased <4>__ShopTerminalBehavior_SetHasBeenPurchased;

			public static hook_GetInteractability <5>__PurchaseInteraction_GetInteractability;

			public static hook_OnInteractionBegin <6>__PurchaseInteraction_OnInteractionBegin;

			public static hook_CurrentPickupIndex <7>__ShopTerminalBehavior_CurrentPickupIndex;

			public static hook_CurrentPickup <8>__ShopTerminalBehavior_CurrentPickup;
		}

		public static PlayerCharacterMasterController currentInteractor;

		private const uint PickupMask = 1u;

		private const uint HiddenMask = 2u;

		private const uint PurchasedMask = 4u;

		private const uint AvailableMask = 8u;

		private const uint CostMask = 16u;

		public static void Hook()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0030: 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_003b: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			object obj = <>O.<0>__PurchaseInteraction_OnSerialize;
			if (obj == null)
			{
				hook_OnSerialize val = PurchaseInteraction_OnSerialize;
				<>O.<0>__PurchaseInteraction_OnSerialize = val;
				obj = (object)val;
			}
			PurchaseInteraction.OnSerialize += (hook_OnSerialize)obj;
			object obj2 = <>O.<1>__ShopTerminalBehavior_OnSerialize;
			if (obj2 == null)
			{
				hook_OnSerialize val2 = ShopTerminalBehavior_OnSerialize;
				<>O.<1>__ShopTerminalBehavior_OnSerialize = val2;
				obj2 = (object)val2;
			}
			ShopTerminalBehavior.OnSerialize += (hook_OnSerialize)obj2;
			object obj3 = <>O.<2>__ShopTerminalBehavior_SetPickup;
			if (obj3 == null)
			{
				hook_SetPickup val3 = ShopTerminalBehavior_SetPickup;
				<>O.<2>__ShopTerminalBehavior_SetPickup = val3;
				obj3 = (object)val3;
			}
			ShopTerminalBehavior.SetPickup += (hook_SetPickup)obj3;
			object obj4 = <>O.<3>__PurchaseInteraction_SetAvailable;
			if (obj4 == null)
			{
				hook_SetAvailable val4 = PurchaseInteraction_SetAvailable;
				<>O.<3>__PurchaseInteraction_SetAvailable = val4;
				obj4 = (object)val4;
			}
			PurchaseInteraction.SetAvailable += (hook_SetAvailable)obj4;
			object obj5 = <>O.<4>__ShopTerminalBehavior_SetHasBeenPurchased;
			if (obj5 == null)
			{
				hook_SetHasBeenPurchased val5 = ShopTerminalBehavior_SetHasBeenPurchased;
				<>O.<4>__ShopTerminalBehavior_SetHasBeenPurchased = val5;
				obj5 = (object)val5;
			}
			ShopTerminalBehavior.SetHasBeenPurchased += (hook_SetHasBeenPurchased)obj5;
			object obj6 = <>O.<5>__PurchaseInteraction_GetInteractability;
			if (obj6 == null)
			{
				hook_GetInteractability val6 = PurchaseInteraction_GetInteractability;
				<>O.<5>__PurchaseInteraction_GetInteractability = val6;
				obj6 = (object)val6;
			}
			PurchaseInteraction.GetInteractability += (hook_GetInteractability)obj6;
			object obj7 = <>O.<6>__PurchaseInteraction_OnInteractionBegin;
			if (obj7 == null)
			{
				hook_OnInteractionBegin val7 = PurchaseInteraction_OnInteractionBegin;
				<>O.<6>__PurchaseInteraction_OnInteractionBegin = val7;
				obj7 = (object)val7;
			}
			PurchaseInteraction.OnInteractionBegin += (hook_OnInteractionBegin)obj7;
			object obj8 = <>O.<7>__ShopTerminalBehavior_CurrentPickupIndex;
			if (obj8 == null)
			{
				hook_CurrentPickupIndex val8 = ShopTerminalBehavior_CurrentPickupIndex;
				<>O.<7>__ShopTerminalBehavior_CurrentPickupIndex = val8;
				obj8 = (object)val8;
			}
			ShopTerminalBehavior.CurrentPickupIndex += (hook_CurrentPickupIndex)obj8;
			object obj9 = <>O.<8>__ShopTerminalBehavior_CurrentPickup;
			if (obj9 == null)
			{
				hook_CurrentPickup val9 = ShopTerminalBehavior_CurrentPickup;
				<>O.<8>__ShopTerminalBehavior_CurrentPickup = val9;
				obj9 = (object)val9;
			}
			ShopTerminalBehavior.CurrentPickup += (hook_CurrentPickup)obj9;
		}

		private static PlayerCharacterMasterController GetPlayer(Interactor activator)
		{
			CharacterBody val = (Object.op_Implicit((Object)(object)activator) ? ((Component)activator).GetComponent<CharacterBody>() : null);
			if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val.master))
			{
				return null;
			}
			return val.master.playerCharacterMasterController;
		}

		private static Interactability PurchaseInteraction_GetInteractability(orig_GetInteractability orig, PurchaseInteraction self, Interactor activator)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			if (!NetworkServer.active || !((Component)self).TryGetComponent<InstancedPurchase>(ref instancedPurchase))
			{
				return orig.Invoke(self, activator);
			}
			bool available = self.available;
			try
			{
				self.available = instancedPurchase.GetOrOriginal(GetPlayer(activator)).available;
				return orig.Invoke(self, activator);
			}
			finally
			{
				self.available = available;
			}
		}

		private static void PurchaseInteraction_OnInteractionBegin(orig_OnInteractionBegin orig, PurchaseInteraction self, Interactor activator)
		{
			if (!NetworkServer.active)
			{
				orig.Invoke(self, activator);
				return;
			}
			PlayerCharacterMasterController val = currentInteractor;
			PlayerCharacterMasterController player = GetPlayer(activator);
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			((Component)self).TryGetComponent<InstancedPurchase>(ref instancedPurchase);
			currentInteractor = player;
			try
			{
				if (Object.op_Implicit((Object)(object)instancedPurchase))
				{
					ApplyState(((Component)self).gameObject, instancedPurchase.GetOrOriginal(player), refreshAnimation: false);
				}
				orig.Invoke(self, activator);
			}
			finally
			{
				currentInteractor = val;
				if (Object.op_Implicit((Object)(object)instancedPurchase))
				{
					RestoreHostView(((Component)self).gameObject, Object.op_Implicit((Object)(object)player) && ((NetworkBehaviour)player).hasAuthority);
					if (Object.op_Implicit((Object)(object)player) && !((NetworkBehaviour)player).hasAuthority)
					{
						instancedPurchase.QueueUpdate(player);
					}
				}
			}
		}

		private static void ShopTerminalBehavior_SetHasBeenPurchased(orig_SetHasBeenPurchased orig, ShopTerminalBehavior self, bool newHasBeenPurchased)
		{
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			if (!NetworkServer.active || !((Component)self).TryGetComponent<InstancedPurchase>(ref instancedPurchase))
			{
				orig.Invoke(self, newHasBeenPurchased);
				return;
			}
			instancedPurchase.GetOrCreate(currentInteractor).hasBeenPurchased = newHasBeenPurchased;
			if (Object.op_Implicit((Object)(object)currentInteractor))
			{
				self.hasBeenPurchased = newHasBeenPurchased;
			}
			else
			{
				UpdateAll(((Component)self).gameObject);
			}
		}

		private static void PurchaseInteraction_SetAvailable(orig_SetAvailable orig, PurchaseInteraction self, bool newAvailable)
		{
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			if (!NetworkServer.active || !((Component)self).TryGetComponent<InstancedPurchase>(ref instancedPurchase))
			{
				orig.Invoke(self, newAvailable);
				return;
			}
			instancedPurchase.GetOrCreate(currentInteractor).available = newAvailable;
			if (Object.op_Implicit((Object)(object)currentInteractor))
			{
				self.available = newAvailable;
			}
			else
			{
				UpdateAll(((Component)self).gameObject);
			}
		}

		private static void ShopTerminalBehavior_SetPickup(orig_SetPickup orig, ShopTerminalBehavior self, UniquePickup newPickup, bool newHidden)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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)
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			if (!NetworkServer.active || !((Component)self).TryGetComponent<InstancedPurchase>(ref instancedPurchase))
			{
				orig.Invoke(self, newPickup, newHidden);
				return;
			}
			InstancedPurchaseStruct orCreate = instancedPurchase.GetOrCreate(currentInteractor);
			orCreate.pickup = newPickup;
			orCreate.hidden = newHidden;
			if (Object.op_Implicit((Object)(object)currentInteractor))
			{
				self.pickup = newPickup;
				self.hidden = newHidden;
			}
			else
			{
				UpdateAll(((Component)self).gameObject);
			}
		}

		private static PickupIndex ShopTerminalBehavior_CurrentPickupIndex(orig_CurrentPickupIndex orig, ShopTerminalBehavior self)
		{
			//IL_0013: 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)
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			if (!NetworkServer.active || !((Component)self).TryGetComponent<InstancedPurchase>(ref instancedPurchase))
			{
				return orig.Invoke(self);
			}
			return instancedPurchase.GetOrOriginal(currentInteractor).pickup.pickupIndex;
		}

		private static UniquePickup ShopTerminalBehavior_CurrentPickup(orig_CurrentPickup orig, ShopTerminalBehavior self)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			if (!NetworkServer.active || !((Component)self).TryGetComponent<InstancedPurchase>(ref instancedPurchase))
			{
				return orig.Invoke(self);
			}
			return instancedPurchase.GetOrOriginal(currentInteractor).pickup;
		}

		private static bool ShopTerminalBehavior_OnSerialize(orig_OnSerialize orig, ShopTerminalBehavior self, NetworkWriter writer, bool initialState)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			if (!((Component)self).TryGetComponent<InstancedPurchase>(ref instancedPurchase))
			{
				return orig.Invoke(self, writer, initialState);
			}
			UniquePickup pickup = self.pickup;
			bool hidden = self.hidden;
			bool hasBeenPurchased = self.hasBeenPurchased;
			InstancedPurchaseStruct orOriginal = instancedPurchase.GetOrOriginal(instancedPurchase.pcClient);
			if (!initialState && !Object.op_Implicit((Object)(object)instancedPurchase.pcClient))
			{
				((NetworkBehaviour)self).m_SyncVarDirtyBits = ((NetworkBehaviour)self).m_SyncVarDirtyBits & 0xFFFFFFF8u;
			}
			try
			{
				self.pickup = orOriginal.pickup;
				self.hidden = orOriginal.hidden;
				self.hasBeenPurchased = orOriginal.hasBeenPurchased;
				return orig.Invoke(self, writer, initialState);
			}
			finally
			{
				self.pickup = pickup;
				self.hidden = hidden;
				self.hasBeenPurchased = hasBeenPurchased;
			}
		}

		private static bool PurchaseInteraction_OnSerialize(orig_OnSerialize orig, PurchaseInteraction self, NetworkWriter writer, bool initialState)
		{
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			if (!((Component)self).TryGetComponent<InstancedPurchase>(ref instancedPurchase))
			{
				return orig.Invoke(self, writer, initialState);
			}
			bool available = self.available;
			int cost = self.cost;
			if (!initialState && !Object.op_Implicit((Object)(object)instancedPurchase.pcClient))
			{
				((NetworkBehaviour)self).m_SyncVarDirtyBits = ((NetworkBehaviour)self).m_SyncVarDirtyBits & 0xFFFFFFF7u;
			}
			try
			{
				self.available = instancedPurchase.GetOrOriginal(instancedPurchase.pcClient).available;
				if (Object.op_Implicit((Object)(object)instancedPurchase.pcClient) && FreeSwaps.IsFreeFor((Component)(object)self, instancedPurchase.pcClient))
				{
					self.cost = 0;
				}
				return orig.Invoke(self, writer, initialState);
			}
			finally
			{
				self.available = available;
				self.cost = cost;
			}
		}

		private static void ApplyState(GameObject shop, InstancedPurchaseStruct state, bool refreshAnimation)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			shop.GetComponent<PurchaseInteraction>().available = state.available;
			ShopTerminalBehavior component = shop.GetComponent<ShopTerminalBehavior>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.pickup = state.pickup;
				component.hidden = state.hidden;
				component.hasBeenPurchased = state.hasBeenPurchased;
				if (refreshAnimation && NetworkClient.active)
				{
					component.UpdatePickupDisplayAndAnimations();
				}
			}
		}

		private static void RestoreHostView(GameObject shop, bool forceAnimation = false)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			InstancedPurchase component = shop.GetComponent<InstancedPurchase>();
			PlayerCharacterMasterController pc = null;
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				if (Object.op_Implicit((Object)(object)instance) && ((NetworkBehaviour)instance).hasAuthority)
				{
					pc = instance;
					break;
				}
			}
			InstancedPurchaseStruct orOriginal = component.GetOrOriginal(pc);
			ShopTerminalBehavior component2 = shop.GetComponent<ShopTerminalBehavior>();
			bool flag = Object.op_Implicit((Object)(object)component2) && (!((UniquePickup)(ref component2.pickup)).Equals(orOriginal.pickup) || component2.hidden != orOriginal.hidden || component2.hasBeenPurchased != orOriginal.hasBeenPurchased);
			ApplyState(shop, orOriginal, forceAnimation || flag);
		}

		public static void UpdateAll(GameObject shop)
		{
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			if (!NetworkServer.active || !shop.TryGetComponent<InstancedPurchase>(ref instancedPurchase))
			{
				return;
			}
			RestoreHostView(shop);
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				if (Object.op_Implicit((Object)(object)instance) && !((NetworkBehaviour)instance).hasAuthority)
				{
					instancedPurchase.QueueUpdate(instance);
				}
			}
		}

		public static void UpdatePlayer(GameObject shop, PlayerCharacterMasterController pc)
		{
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			if (NetworkServer.active && Object.op_Implicit((Object)(object)pc) && shop.TryGetComponent<InstancedPurchase>(ref instancedPurchase))
			{
				if (((NetworkBehaviour)pc).hasAuthority)
				{
					RestoreHostView(shop);
				}
				else
				{
					instancedPurchase.QueueUpdate(pc);
				}
			}
		}

		private static byte[] CreateUpdateMessage(NetworkIdentity identity, int channel, uint shopMask, uint purchaseMask)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			NetworkWriter val = new NetworkWriter();
			val.StartMessage((short)8);
			val.Write(identity.netId);
			NetworkBehaviour[] behavioursOfSameChannel = identity.GetBehavioursOfSameChannel(channel, false);
			foreach (NetworkBehaviour val2 in behavioursOfSameChannel)
			{
				uint syncVarDirtyBits = val2.m_SyncVarDirtyBits;
				try
				{
					val2.m_SyncVarDirtyBits = ((val2 is ShopTerminalBehavior) ? shopMask : ((val2 is PurchaseInteraction) ? purchaseMask : 0u));
					val2.OnSerialize(val, false);
				}
				finally
				{
					val2.m_SyncVarDirtyBits = syncVarDirtyBits;
				}
			}
			val.FinishMessage();
			return val.ToArray();
		}

		public static void PlayBuySound(ShopTerminalBehavior shop, PlayerCharacterMasterController buyer)
		{
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			NetworkIdentity val = (Object.op_Implicit((Object)(object)shop) ? ((Component)shop).GetComponent<NetworkIdentity>() : null);
			if (!NetworkServer.active || !Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			InstancedPurchase instancedPurchase = default(InstancedPurchase);
			((Component)shop).TryGetComponent<InstancedPurchase>(ref instancedPurchase);
			int networkChannel = ((NetworkBehaviour)shop).GetNetworkChannel();
			foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
			{
				if (!Object.op_Implicit((Object)(object)instance) || (Object.op_Implicit((Object)(object)instancedPurchase) && (Object)(object)instance != (Object)(object)buyer))
				{
					continue;
				}
				if (((NetworkBehaviour)instance).hasAuthority)
				{
					Util.PlaySound("Play_UI_tripleChestShutter", ((Component)shop).gameObject);
					continue;
				}
				NetworkConnection val2 = (Object.op_Implicit((Object)(object)instance.networkUser) ? ((NetworkBehaviour)instance.networkUser).connectionToClient : null);
				if (val2 == null || !val2.isReady || val.observers == null || !val.observers.Contains(val2))
				{
					continue;
				}
				InstancedPurchaseStruct instancedPurchaseStruct = (Object.op_Implicit((Object)(object)instancedPurchase) ? instancedPurchase.GetOrOriginal(instance) : null);
				UniquePickup pickup = instancedPurchaseStruct?.pickup ?? shop.pickup;
				PlayerCharacterMasterController pcClient = (Object.op_Implicit((Object)(object)instancedPurchase) ? instancedPurchase.pcClient : null);
				try
				{
					if (Object.op_Implicit((Object)(object)instancedPurchase))
					{
						instancedPurchase.pcClient = instance;
						instancedPurchaseStruct.pickup = UniquePickup.none;
					}
					else
					{
						shop.pickup = UniquePickup.none;
					}
					byte[] array = CreateUpdateMessage(val, networkChannel, 1u, 0u);
					if (Object.op_Implicit((Object)(object)instancedPurchase))
					{
						instancedPurchaseStruct.pickup = pickup;
					}
					else
					{
						shop.pickup = pickup;
					}
					byte[] array2 = CreateUpdateMessage(val, networkChannel, 1u, 0u);
					byte[] array3 = new byte[array.Length + array2.Length];
					Buffer.BlockCopy(array, 0, array3, 0, array.Length);
					Buffer.BlockCopy(array2, 0, array3, array.Length, array2.Length);
					if (!val2.SendBytes(array3, array3.Length, networkChannel))
					{
						Log.LogWarning("Could not play a shop's buy sound for a client.");
					}
				}
				finally
				{
					if (Object.op_Implicit((Object)(object)instancedPurchase))
					{
						instancedPurchaseStruct.pickup = pickup;
						instancedPurchase.pcClient = pcClient;
					}
					else
					{
						shop.pickup = pickup;
					}
				}
			}
		}

		internal static byte[] CreatePickupDisplayRefresh(NetworkIdentity identity, NetworkConnection connection, int channel)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			ShopTerminalBehavior component = ((Component)identity).GetComponent<ShopTerminalBehavior>();
			InstancedPurchase component2 = ((Component)identity).GetComponent<InstancedPurchase>();
			PlayerCharacterMasterController val = null;
			InstancedPurchaseStruct instancedPurchaseStruct = null;
			if (Object.op_Implicit((Object)(object)component2))
			{
				foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
				{
					if (Object.op_Implicit((Object)(object)instance) && Object.op_Implicit((Object)(object)instance.networkUser) && ((NetworkBehaviour)instance.networkUser).connectionToClient == connection)
					{
						val = instance;
						break;
					}
				}
				if (!Object.op_Implicit((Object)(object)val))
				{
					return null;
				}
				instancedPurchaseStruct = component2.GetOrOriginal(val);
			}
			UniquePickup val2 = instancedPurchaseStruct?.pickup ?? component.pickup;
			if (((UniquePickup)(ref val2)).Equals(UniquePickup.none))
			{
				return Array.Empty<byte>();
			}
			bool flag = instancedPurchaseStruct?.hidden ?? component.hidden;
			PlayerCharacterMasterController pcClient = (Object.op_Implicit((Object)(object)component2) ? component2.pcClient : null);
			try
			{
				if (Object.op_Implicit((Object)(object)component2))
				{
					component2.pcClient = val;
					instancedPurchaseStruct.hidden = !flag;
				}
				else
				{
					component.hidden = !flag;
				}
				byte[] array = CreateUpdateMessage(identity, channel, 2u, 0u);
				if (instancedPurchaseStruct != null)
				{
					instancedPurchaseStruct.hidden = flag;
				}
				else
				{
					component.hidden = flag;
				}
				byte[] array2 = CreateUpdateMessage(identity, channel, 3u, 0u);
				byte[] array3 = CreateUpdateMessage(identity, channel, 1u, 0u);
				NetworkWriter val3 = new NetworkWriter();
				val3.Write(array, array.Length);
				val3.Write(array2, array2.Length);
				val3.Write(array3, array3.Length);
				return val3.ToArray();
			}
			finally
			{
				if (Object.op_Implicit((Object)(object)component2))
				{
					instancedPurchaseStruct.hidden = flag;
					component2.pcClient = pcClient;
				}
				else
				{
					component.hidden = flag;
				}
			}
		}

		internal static bool SendUpdateToClient(InstancedPurchase instance, PlayerCharacterMasterController pc)
		{
			NetworkIdentity component = ((Component)instance).GetComponent<NetworkIdentity>();
			NetworkConnection val = (Object.op_Implicit((Object)(object)pc.networkUser) ? ((NetworkBehaviour)pc.networkUser).connectionToClient : null);
			if (val == null || !val.isReady || !Object.op_Implicit((Object)(object)component) || component.observers == null || !component.observers.Contains(val) || Util.ConnectionIsLocal(val))
			{
				return false;
			}
			PlayerCharacterMasterController pcClient = instance.pcClient;
			try
			{
				instance.pcClient = pc;
				ShopTerminalBehavior component2 = ((Component)instance).GetComponent<ShopTerminalBehavior>();
				int networkChannel;
				byte[] array3;
				if (Object.op_Implicit((Object)(object)component2))
				{
					networkChannel = ((NetworkBehaviour)component2).GetNetworkChannel();
					byte[] array = CreateUpdateMessage(component, networkChannel, 4u, 0u);
					byte[] array2 = CreateUpdateMessage(component, networkChannel, 3u, 24u);
					array3 = new byte[array.Length + array2.Length];
					Buffer.BlockCopy(array, 0, array3, 0, array.Length);
					Buffer.BlockCopy(array2, 0, array3, array.Length, array2.Length);
				}
				else
				{
					networkChannel = ((NetworkBehaviour)((Component)instance).GetComponent<PurchaseInteraction>()).GetNetworkChannel();
					array3 = CreateUpdateMessage(component, networkChannel, 0u, 8u);
				}
				if (val.SendBytes(array3, array3.Length, networkChannel))
				{
					return true;
				}
				Log.LogWarning($"Could not update instanced shop for {val.connectionId}; retrying");
				return false;
			}
			catch (Exception arg)
			{
				Log.LogError($"Instanced shop sync failed: {arg}");
				return false;
			}
			finally
			{
				instance.pcClient = pcClient;
			}
		}
	}
	internal class LanguageAPI
	{
		public static string NEWT_DONATE_LIST1 = "NEWT_DONATE_LIST1";

		public static string NEWT_DONATE_LIST2 = "NEWT_DONATE_LIST2";

		public static string NEWT_DONATE_LIST3 = "NEWT_DONATE_LIST3";

		public static string NEWT_DONATE_LIST_CHARACTER = "NEWT_DONATE_LIST_CHARACTER";

		public static string NEWT_DEATH_STATE = "NEWT_DEATH_STATE";

		public static string NEWT_DEATH_INFO = "NEWT_DEATH_INFO";

		public static string[] NEWT_WELCOME_WORD = new string[5] { "NEWT_WELCOME_WORD_1", "NEWT_WELCOME_WORD_2", "NEWT_WELCOME_WORD_3", "NEWT_WELCOME_WORD_4", "NEWT_WELCOME_WORD_5" };

		public static string[] NEWT_ANGRY_WELCOME_WORD = new string[5] { "NEWT_ANGRY_WELCOME_WORD_1", "NEWT_ANGRY_WELCOME_WORD_2", "NEWT_ANGRY_WELCOME_WORD_3", "NEWT_ANGRY_WELCOME_WORD_4", "NEWT_ANGRY_WELCOME_WORD_5" };

		public static string[] NEWT_WELCOME = Tokens("NEWT_WELCOME_", 5);

		public static string[] NEWT_ANGRY_WELCOME = Tokens("NEWT_ANGRY_WELCOME_", 5);

		public static string[] NEWT_UPGRADE = Tokens("NEWT_UPGRADE_", 3);

		public static string[] NEWT_LUNAR_PURCHASE = Tokens("NEWT_LUNAR_PURCHASE_", 8);

		public static string[] NEWT_ANNOY = Tokens("NEWT_ANNOY_", 6);

		public static string[] NEWT_ATTACKED_WORD = new string[10] { "NEWT_ATTACKED_WORD_1", "NEWT_ATTACKED_WORD_2", "NEWT_ATTACKED_WORD_3", "NEWT_ATTACKED_WORD_4", "NEWT_ATTACKED_WORD_5", "NEWT_ATTACKED_WORD_6", "NEWT_ATTACKED_WORD_7", "NEWT_ATTACKED_WORD_8", "NEWT_ATTACKED_WORD_9", "NEWT_ATTACKED_WORD_10" };

		private static string[] Tokens(string prefix, int count)
		{
			return (from number in Enumerable.Range(1, count)
				select prefix + number).ToArray();
		}
	}
	internal static class Log
	{
		internal static ManualLogSource _logSource;

		public static ManualLogSource GetSource()
		{
			return _logSource;
		}

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void LogDebug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void LogError(object data)
		{
			_logSource.LogError(data);
		}

		internal static void LogFatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void LogInfo(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void LogMessage(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void LogWarning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInIncompatibility("com.Lunzir.BazaarLunarForEveryone")]
	[BepInPlugin("Def.BazaarIsMyHaven", "BazaarIsMyHaven", "5.1.0")]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Main : BaseUnityPlugin
	{
		public static PluginInfo PluginInfo;

		public static Main instance;

		public const string PluginGUID = "Def.BazaarIsMyHaven";

		public const string PluginAuthor = "Def";

		public const string PluginName = "BazaarIsMyHaven";

		public const string PluginVersion = "5.1.0";

		private static Random Random = new Random();

		private List<BazaarBase> bazaarMods = new List<BazaarBase>();

		private readonly Dictionary<PlayerCharacterMasterController, PlayerStruct> playerStructs_ = new Dictionary<PlayerCharacterMasterController, PlayerStruct>();

		public AsyncOperationHandle<GameObject> pickupTakenOrbPrefab;

		private const string NewtKarmaTriggerName = "KickedOutOfBazaar";

		private bool raisingNewtKarmaOnKill;

		private bool raisedNewtKarmaThisVisit;

		public PlayerStruct GetPlayerStruct(PlayerCharacterMasterController master)
		{
			if (!playerStructs_.ContainsKey(master))
			{
				playerStructs_.Add(master, new PlayerStruct(master));
			}
			return playerStructs_[master];
		}

		public void Awake()
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			PluginInfo = ((BaseUnityPlugin)this).Info;
			instance = this;
			Log.Init(((BaseUnityPlugin)this).Logger);
			bazaarMods.Add(new BazaarCauldron());
			bazaarMods.Add(new BazaarPrinter());
			bazaarMods.Add(new BazaarRestack());
			bazaarMods.Add(new BazaarDonate());
			bazaarMods.Add(new BazaarScrapper());
			bazaarMods.Add(new BazaarEquipment());
			bazaarMods.Add(new BazaarLunarShop());
			bazaarMods.Add(new BazaarCleansingPool());
			bazaarMods.Add(new BazaarDecorate());
			bazaarMods.Add(new BazaarWanderingChef());
			bazaarMods.Add(new BazaarDrones());
			bazaarMods.Add(new BazaarCommandPedestal());
			pickupTakenOrbPrefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC3/MealPrep/PickupTakenOrbEffect.prefab");
			foreach (BazaarBase bazaarMod in bazaarMods)
			{
				bazaarMod.Preload();
			}
			RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, (Action)delegate
			{
				ModConfig.InitConfig(((BaseUnityPlugin)this).Config);
				Hook();
			});
		}

		private void Hook()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			foreach (BazaarBase bazaarMod in bazaarMods)
			{
				bazaarMod.Hook();
			}
			InstancedPurchases.Hook();
			PriceSigns.Hook();
			FreeSwaps.Hook();
			Run.Start += new hook_Start(Run_Start);
			Run.onRunDestroyGlobal += Run_Destroy;
			BazaarController.SetUpSeerStations += new hook_SetUpSeerStations(BazaarController_SetUpSeerStations);
			SceneDirector.onPrePopulateSceneServer += SceneDirector_onPrePopulateSceneServer;
			TeleporterInteraction.Start += new hook_Start(TeleporterInteraction_Start);
			DrifterBagController.AssignPassenger += new hook_AssignPassenger(DrifterBagController_AssignPassenger);
			JunkController.GenerateJunk += new hook_GenerateJunk(JunkController_GenerateJunk);
			Inventory.onServerItemGiven += Inventory_onServerItemGiven;
			TinkerProjectile.TransmuteTargetObject += new hook_TransmuteTargetObject(TinkerProjectile_TransmuteTargetObject);
			UnlockTargetState.OnEnter += new hook_OnEnter(UnlockTargetState_OnEnter);
			Util.KarmaEventTrigger += new hook_KarmaEventTrigger(Util_KarmaEventTrigger);
			KickFromShop.FixedUpdate += new hook_FixedUpdate(KickFromShop_FixedUpdate);
			GlobalEventManager.OnHitAll += new hook_OnHitAll(GlobalEventManager_OnHitAll);
			CharacterMaster.OnBodyDeath += new hook_OnBodyDeath(CharacterMaster_OnBodyDeath);
			SpawnState.OnEnter += new hook_OnEnter(SpawnState_OnEnter);
		}

		private void Run_Start(orig_Start orig, Run self)
		{
			ShopKeeper.DiedAtLeastOnce = false;
			ShopKeeper.Body = null;
			playerStructs_.Clear();
			orig.Invoke(self);
			if (NetworkServer.active)
			{
				ModConfig.ReloadConfig(((BaseUnityPlugin)this).Config);
			}
			if (!ModConfig.EnableMod.Value || !NetworkServer.active)
			{
				return;
			}
			foreach (BazaarBase bazaarMod in bazaarMods)
			{
				bazaarMod.RunStart();
			}
		}

		private void Run_Destroy(Run run)
		{
			playerStructs_.Clear();
			ShopKeeper.Body = null;
			InstancedPurchases.currentInteractor = null;
			foreach (BazaarBase bazaarMod in bazaarMods)
			{
				bazaarMod.RunEnd();
			}
		}

		private void BazaarController_SetUpSeerStations(orig_SetUpSeerStations orig, BazaarController self)
		{
			if (ModConfig.EnableMod.Value && NetworkServer.active && (ModConfig.LunarSeerSectionEnabled.Value || (ModConfig.EquipmentSectionEnabled.Value && ModConfig.EquipmentReplaceLunarSeersWithEquipment.Value)))
			{
				SeerStationController[] seerStations = self.seerStations;
				foreach (SeerStationController val in seerStations)
				{
					bool flag = ModConfig.LunarSeerAvailable.Value;
					if (ModConfig.EquipmentSectionEnabled.Value && ModConfig.EquipmentReplaceLunarSeersWithEquipment.Value)
					{
						flag = false;
					}
					((Component)val).GetComponent<PurchaseInteraction>().available = flag;
					((Component)val).GetComponent<PurchaseInteraction>().Networkavailable = flag;
					if (ModConfig.LunarSeerSectionEnabled.Value && flag)
					{
						((Component)val).GetComponent<PurchaseInteraction>().cost = ModConfig.LunarSeerCost.Value;
						((Component)val).GetComponent<PurchaseInteraction>().Networkcost = ModConfig.LunarSeerCost.Value;
					}
				}
			}
			orig.Invoke(self);
		}

		private void SceneDirector_onPrePopulateSceneServer(SceneDirector obj)
		{
			if (!ModConfig.EnableMod.Value || !IsCurrentMapInBazaar() || !NetworkServer.active)
			{
				return;
			}
			ShopKeeper.Body = null;
			ShopKeeper.DeathCount = 0;
			raisedNewtKarmaThisVisit = false;
			playerStructs_.Clear();
			ArtifactDef val = ArtifactCatalog.FindArtifactDef("Sacrifice");
			bool flag = false;
			if (RunArtifactManager.instance.IsArtifactEnabled(val))
			{
				flag = true;
				RunArtifactManager.instance.SetArtifactEnabledServer(val, false);
			}
			try
			{
				List<DirectorCard> cards = new List<DirectorCard>();
				foreach (BazaarBase bazaarMod in bazaarMods)
				{
					try
					{
						bazaarMod.AddDirectorCards(cards);
					}
					catch (Exception arg)
					{
						Log.LogError($"Could not add the director cards of {bazaarMod.GetType().Name}: {arg}");
					}
				}
				int credits = BazaarDirector.Spend(BazaarDirector.Credits, cards, "setup");
				foreach (BazaarBase bazaarMod2 in bazaarMods)
				{
					try
					{
						bazaarMod2.SetupBazaar();
					}
					catch (Exception arg2)
					{
						Log.LogError($"Could not set up {bazaarMod2.GetType().Name}: {arg2}");
					}
				}
				BazaarDirector.Create(bazaarMods, cards, credits);
			}
			finally
			{
				if (flag)
				{
					RunArtifactManager.instance.SetArtifactEnabledServer(val, true);
				}
			}
		}

		private void TeleporterInteraction_Start(orig_Start orig, TeleporterInteraction self)
		{
			orig.Invoke(self);
			if (ModConfig.EnableMod.Value && ModConfig.AlwaysSpawnShopPortal.Value && NetworkServer.active)
			{
				self.shouldAttemptToSpawnShopPortal = true;
			}
		}

		private bool IsDrifterJunkPrevented()
		{
			if (ModConfig.EnableMod.Value && ModConfig.PreventDrifterJunk.Value && IsCurrentMapInBazaar())
			{
				return NetworkServer.active;
			}
			return false;
		}

		private void JunkController_GenerateJunk(orig_GenerateJunk orig, JunkController self, Vector3 dropLocation, int quantity)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!IsDrifterJunkPrevented())
			{
				orig.Invoke(self, dropLocation, quantity);
			}
		}

		private void Inventory_onServerItemGiven(Inventory inventory, ItemIndex itemIndex, int count)
		{
			//IL_000c: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Items.Junk) && itemIndex == Items.Junk.itemIndex && IsDrifterJunkPrevented())
			{
				inventory.RemoveItemPermanent(itemIndex, count);
			}
		}

		private void UnlockTargetState_OnEnter(orig_OnEnter orig, UnlockTargetState self)
		{
			PurchaseInteraction target = self.target;
			if (!ModConfig.EnableMod.Value || !NetworkServer.active || !IsCurrentMapInBazaar() || !Object.op_Implicit((Object)(object)target))
			{
				orig.Invoke(self);
				return;
			}
			int cost = target.cost;
			orig.Invoke(self);
			if (Object.op_Implicit((Object)(object)target) && target.cost != cost)
			{
				target.Networkcost = cost;
			}
		}

		private void TinkerProjectile_TransmuteTargetObject(orig_TransmuteTargetObject orig, TinkerProjectile self, GameObject targetObject)
		{
			if (!ModConfig.EnableMod.Value || !ModConfig.PreventDrifterTinker.Value || !IsCurrentMapInBazaar() || !NetworkServer.active)
			{
				orig.Invoke(self, targetObject);
			}
		}

		private void DrifterBagController_AssignPassenger(orig_AssignPassenger orig, DrifterBagController self, GameObject passengerObject)
		{
			if (ModConfig.EnableMod.Value && ModConfig.PreventDrifterBagging.Value && IsCurrentMapInBazaar() && NetworkServer.active && Object.op_Implicit((Object)(object)passengerObject))
			{
				if (self.isAuthority)
				{
					self.EmptyBagAuthority();
				}
				else
				{
					self.CallRpcEmptyBag();
				}
			}
			else
			{
				orig.Invoke(self, passengerObject);
			}
		}

		private bool Util_KarmaEventTrigger(orig_KarmaEventTrigger orig, string identifier)
		{
			if (identifier != "KickedOutOfBazaar" || !ModConfig.EnableMod.Value || !ModConfig.NewtSectionEnabled.Value || !IsCurrentMapInBazaar())
			{
				return orig.Invoke(identifier);
			}
			if (ModConfig.NewtKarmaTrigger.Value == ShopKeeper.KarmaTrigger.OnKill && !raisingNewtKarmaOnKill)
			{
				return false;
			}
			if (ModConfig.NewtKarmaTriggerOncePerVisit.Value && raisedNewtKarmaThisVisit)
			{
				return false;
			}
			bool flag = orig.Invoke(identifier);
			raisedNewtKarmaThisVisit |= flag;
			return flag;
		}

		private void RaiseNewtKarmaOnKill()
		{
			raisingNewtKarmaOnKill = true;
			try
			{
				Util.KarmaEventTrigger("KickedOutOfBazaar");
			}
			finally
			{
				raisingNewtKarmaOnKill = false;
			}
		}

		private void KickFromShop_FixedUpdate(orig_FixedUpdate orig, KickFromShop self)
		{
			if (ModConfig.EnableMod.Value && ModConfig.NewtSectionEnabled.Value && ModConfig.NewtNoKickFromShop.Value && IsCurrentMapInBazaar() && IsShopkeeper(((Component)((EntityState)self).outer).gameObject) && NetworkServer.active)
			{
				if (!ShopKeeper.DiedAtLeastOnce)
				{
					ChatHelper.HitWord();
				}
				_ = ModConfig.NewtDeathBehavior.Value;
				_ = 3;
				((EntityState)self).outer.SetNextStateToMain();
			}
			else
			{
				orig.Invoke(self);
			}
		}

		private void GlobalEventManager_OnHitAll(orig_OnHitAll orig, GlobalEventManager self, DamageInfo damageInfo, GameObject hitObject)
		{
			if (ModConfig.EnableMod.Value && ModConfig.NewtSectionEnabled.Value && ModConfig.NewtDialogue.Value != ShopKeeper.Dialogue.Off && IsCurrentMapInBazaar() && NetworkServer.active && (Object)(object)hitObject != (Object)null && ((Object)hitObject).name.StartsWith("ShopkeeperBody") && (Object)(object)damageInfo.attacker != (Object)null)
			{
				float num = damageInfo.damage / hitObject.GetComponent<HealthComponent>().fullCombinedHealth;
				if (Random.NextDouble() < (double)(num / 2f))
				{
					ChatHelper.HitWord();
				}
			}
			orig.Invoke(self, damageInfo, hitObject);
		}

		private void CharacterMaster_OnBodyDeath(orig_OnBodyDeath orig, CharacterMaster self, CharacterBody body)
		{
			orig.Invoke(self, body);
			if (!ModConfig.EnableMod.Value || !ModConfig.NewtSectionEnabled.Value || !IsCurrentMapInBazaar() || !NetworkServer.active || !((Object)body).name.Contains("ShopkeeperBody"))
			{
				return;
			}
			ShopKeeper.DiedAtLeastOnce = true;
			ShopKeeper.DeathCount++;
			if (ModConfig.NewtKarmaTrigger.Value == ShopKeeper.KarmaTrigger.OnKill)
			{
				RaiseNewtKarmaOnKill();
			}
			if (ModConfig.NewtDeathBehavior.Value == ShopKeeper.DeathState.Default)
			{
				if (ModConfig.NewtDialogue.Value == ShopKeeper.Dialogue.BazaarIsMyHome)
				{
					ChatHelper.ShowNewtDeath();
				}
			}
			else
			{
				AddItemToShopKeeper(body);
			}
		}

		private void SpawnState_OnEnter(orig_OnEnter orig, SpawnState self)
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.EnableMod.Value && ModConfig.NewtSectionEnabled.Value && IsCurrentMapInBazaar() && IsShopkeeper(((Component)((EntityState)self).outer).gameObject) && NetworkServer.active)
			{
				if (ModConfig.NewtDialogue.Value != ShopKeeper.Dialogue.Off)
				{
					((MonoBehaviour)this).StartCoroutine(ShopWelcomeWord());
				}
				if (!Object.op_Implicit((Object)(object)ShopKeeper.Body))
				{
					FindShopkeeper();
				}
				if (Object.op_Implicit((Object)(object)ShopKeeper.Body) && Object.op_Implicit((Object)(object)ShopKeeper.Body.inventory) && ModConfig.NewtDeathBehavior.Value != ShopKeeper.DeathState.Default)
				{
					ShopKeeper.Body.inventory.GiveItemPermanent(ItemCatalog.GetItemDef(ItemCatalog.FindItemIndex("ExtraLife")), 1000);
					int num = ((ModConfig.NewtDeathBehavior.Value == ShopKeeper.DeathState.Tank) ? 300 : 200);
					ShopKeeper.Body.inventory.GiveItemPermanent(ItemCatalog.GetItemDef(ItemCatalog.FindItemIndex("CutHp")), num);
				}
			}
			orig.Invoke(self);
		}

		private static bool IsShopkeeper(GameObject gameObject)
		{
			if (Object.op_Implicit((Object)(object)gameObject))
			{
				return ((Object)gameObject).name.StartsWith("ShopkeeperBody");
			}
			return false;
		}

		private void AddItemToShopKeeper(CharacterBody body)
		{
			//IL_008e: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			switch (ModConfig.NewtDeathBehavior.Value)
			{
			case ShopKeeper.DeathState.Ghost:
				ShopKeeper.Body.inventory.GiveItemPermanent(ItemCatalog.GetItemDef(ItemCatalog.FindItemIndex("Ghost")), 1);
				ShopKeeper.Body.AddBuff(Buffs.HiddenInvincibility);
				break;
			case ShopKeeper.DeathState.Tank:
			{
				int num = 10 * (int)Math.Pow(2.0, ShopKeeper.DeathCount) - 10 * (int)Math.Pow(2.0, ShopKeeper.DeathCount - 1);
				body.inventory.GiveItemPermanent(ItemCatalog.GetItemDef(ItemCatalog.FindItemIndex("BoostHp")), num);
				break;
			}
			case ShopKeeper.DeathState.Hostile:
				body.inventory.GiveItemPermanent(ItemCatalog.GetItemDef(ItemCatalog.FindItemIndex("Thorns")), 1);
				break;
			}
		}

		private IEnumerator ShopWelcomeWord()
		{
			yield return (object)new WaitForSeconds(0.5f);
			ChatHelper.WelcomeWord();
		}

		private void FindShopkeeper()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			TeamIndex val = (TeamIndex)0;
			CharacterMaster[] array = Object.FindObjectsOfType<CharacterMaster>();
			foreach (CharacterMaster val2 in array)
			{
				if (val2.teamIndex == val)
				{
					CharacterBody body = val2.GetBody();
					if (Object.op_Implicit((Object)(object)body) && ((Object)body).name.StartsWith("ShopkeeperBody"))
					{
						ShopKeeper.Body = body;
						break;
					}
				}
			}
		}

		private bool IsCurrentMapInBazaar()
		{
			//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)
			Scene activeScene = SceneManager.GetActiveScene();
			return ((Scene)(ref activeScene)).name == "bazaar";
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void Command_SpawnCard(ConCommandArgs args)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			string argString = ((ConCommandArgs)(ref args)).GetArgString(0);
			NetworkUser networkUser = PlayerCharacterMasterController.instances[0].networkUser;
			ChatHelper.Send("name = " + argString + ", DisplayName = " + networkUser.masterController.GetDisplayName());
			Vector3 footPosition = networkUser.GetCurrentBody().footPosition;
			SpawnCard val = Addressables.LoadAssetAsync<SpawnCard>((object)argString).WaitForCompletion();
			DirectorPlacementRule val2 = new DirectorPlacementRule
			{
				placementMode = (PlacementMode)0
			};
			val.DoSpawn(footPosition, Quaternion.identity, new DirectorSpawnRequest(val, val2, Run.instance.runRNG)).spawnedInstance.transform.eulerAngles = new Vector3(0f, 220f, 0f);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void Command_GameObject(ConCommandArgs args)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			string argString = ((ConCommandArgs)(ref args)).GetArgString(0);
			NetworkUser networkUser = PlayerCharacterMasterController.instances[0].networkUser;
			ChatHelper.Send("name = " + argString + ", DisplayName = " + networkUser.masterController.GetDisplayName());
			Vector3 footPosition = networkUser.GetCurrentBody().footPosition;
			GameObject obj = Object.Instantiate<GameObject>(Addressables.LoadAssetAsync<GameObject>((object)argString).WaitForCompletion(), footPosition, Quaternion.identity);
			obj.transform.eulerAngles = new Vector3(0f, 220f, 0f);
			NetworkServer.Spawn(obj);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void Command_PlayEffect(ConCommandArgs args)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			string argString = ((ConCommandArgs)(ref args)).GetArgString(0);
			Vector3 corePosition = PlayerCharacterMasterController.instances[0].networkUser.GetCurrentBody().corePosition;
			float scale = 1f;
			float? num = ((ConCommandArgs)(ref args)).TryGetArgFloat(1);
			if (num.HasValue)
			{
				scale = num.Value;
			}
			EffectManager.SpawnEffect(Addressables.LoadAssetAsync<GameObject>((object)argString).WaitForCompletion(), new EffectData
			{
				origin = corePosition,
				rotation = Quaternion.identity,
				scale = scale,
				color = Color32.op_Implicit(Color.yellow)
			}, true);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void Command_NextChefItem(ConCommandArgs args)
		{
			foreach (BazaarBase bazaarMod in instance.bazaarMods)
			{
				if (bazaarMod is BazaarWanderingChef bazaarWanderingChef)
				{
					bazaarWanderingChef.NextRecipe();
				}
			}
		}
	}
	public static class ModCompatibilityInLobbyConfig
	{
		private static bool? _enabled;

		public static bool enabled
		{
			get
			{
				if (!_enabled.HasValue)
				{
					_enabled = Chainloader.PluginInfos.ContainsKey("com.KingEnderBrine.InLobbyConfig");
				}
				return _enabled.Value;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void CreateFromBepInExConfigFile(ConfigFile config, string displayName)
		{
			ModConfigEntry val = ConfigFieldUtilities.CreateFromBepInExConfigFile(config, displayName);
			foreach (KeyValuePair<string, IEnumerable<IConfigField>> sectionField in val.SectionFields)
			{
				List<IConfigField> list = new List<IConfigField>();
				foreach (IConfigField item in sectionField.Value)
				{
					if (item.DisplayName.Equals("SectionEnabled", StringComparison.InvariantCultureIgnoreCase))
					{
						list.Add(item);
					}
				}
				foreach (IConfigField item2 in list)
				{
					(sectionField.Value as List<IConfigField>).Remove(item2);
				}
			}
			ModConfigCatalog.Add(val);
		}
	}
	public static class ModCompatibilityQoLChests
	{
		private static bool? _enabled;

		private static BaseUnityPlugin _plugin;

		public static bool enabled
		{
			get
			{
				if (!_enabled.HasValue)
				{
					_enabled = Chainloader.PluginInfos.ContainsKey("Faust.QoLChests");
				}
				return _enabled.Value;
			}
		}

		public static BaseUnityPlugin plugin
		{
			get
			{
				if ((Object)(object)_plugin == (Object)null && Chainloader.PluginInfos.TryGetValue("Faust.QoLChests", out var value))
				{
					_plugin = value.Instance;
				}
				return _plugin;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void RegisterQoLChestsBlacklist(string LunarShopObjectName)
		{
			if ((Object)(object)plugin == (Object)null)
			{
				return;
			}
			try
			{
				MethodInfo methodInfo = ((object)plugin).GetType().Assembly.GetType("Faust.QoLChests.Handlers.InteractableRegistry")?.GetMethod("BlackList", new Type[1] { typeof(string) });
				if (methodInfo == null)
				{
					Log.LogWarning("Could not find QoLChests' blacklist API; buds may get hidden.");
					return;
				}
				methodInfo.Invoke(null, new object[1] { LunarShopObjectName });
			}
			catch (Exception arg)
			{
				Log.LogWarning($"Could not exempt buds from QoLChests: {arg}");
			}
		}
	}
	public static class ModCompatibilityShareSuite
	{
		private static bool? _enabled;

		private static BaseUnityPlugin _plugin;

		private static ConfigEntry<bool> printerCauldronFix;

		private static bool fieldChecked;

		public static bool enabled
		{
			get
			{
				if (!_enabled.HasValue)
				{
					_enabled = Chainloader.PluginInfos.ContainsKey("com.funkfrog_sipondo.sharesuite");
				}
				return _enabled.Value;
			}
		}

		public static BaseUnityPlugin plugin
		{
			get
			{
				if ((Object)(object)_plugin == (Object)null)
				{
					foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
					{
						if (pluginInfo.Key == "com.funkfrog_sipondo.sharesuite")
						{
							_plugin = pluginInfo.Value.Instance;
						}
					}
				}
				return _plugin;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool IsShareSuite_PrinterCauldronFixEnabled()
		{
			if (!fieldChecked)
			{
				fieldChecked = true;
				try
				{
					if ((Object)(object)plugin != (Object)null)
					{
						printerCauldronFix = Reflection.GetFieldValue<ConfigEntry<bool>>((object)plugin, "PrinterCauldronFixEnabled");
					}
				}
				catch (Exception ex)
				{
					Log.LogWarning("Could not read ShareSuite's cauldron setting - " + ex.Message);
				}
			}
			if (printerCauldronFix != null)
			{
				return printerCauldronFix.Value;
			}
			return false;
		}
	}
	internal class ModConfig
	{
		public class CommandPedestalTier
		{
			public string name;

			public Func<Run, List<PickupIndex>> dropList;

			public ConfigEntry<int> directorCost;

			public ConfigEntry<float> weight;

			public ConfigEntry<int> cost;
		}

		public static ConfigEntry<bool> EnableMod;

		public static ConfigEntry<bool> AlwaysSpawnShopPortal;

		public static ConfigEntry<bool> ScaleMoneyCosts;

		public static ConfigEntry<bool> PreventDrifterBagging;

		public static ConfigEntry<bool> PreventDrifterJunk;

		public static ConfigEntry<bool> PreventDrifterTinker;

		public static ConfigEntry<int> DirectorExtraCredits;

		public static ConfigEntry<int> DirectorCreditsPerStage;

		public static ConfigEntry<int> DirectorCreditsCap;

		public static ConfigEntry<bool> NewtSectionEnabled;

		public static ConfigEntry<bool> NewtNoKickFromShop;

		public static ConfigEntry<ShopKeeper.KarmaTrigger> NewtKarmaTrigger;

		public static ConfigEntry<bool> NewtKarmaTriggerOncePerVisit;

		public static ConfigEntry<ShopKeeper.DeathState> NewtDeathBehavior;

		public static ConfigEntry<ShopKeeper.Dialogue> NewtDialogue;

		public static ConfigEntry<bool> PrinterSectionEnabled;

		public static ConfigEntry<int> PrinterMaxAmount;

		public static ConfigEntry<float> PrinterDirectorWeight;

		public static ConfigEntry<int> PrinterDirectorCostWhite;

		public static ConfigEntry<int> PrinterDirectorCostGreen;

		public static ConfigEntry<int> PrinterDirectorCostRed;

		public static ConfigEntry<int> PrinterDirectorCostBoss;

		public static ConfigEntry<float> PrinterTier1Weight;

		public static ConfigEntry<float> PrinterTier2Weight;

		public static ConfigEntry<float> PrinterTier3Weight;

		public static ConfigEntry<float> PrinterTierBossWeight;

		public static ConfigEntry<float> PrinterTierVoid1Weight;

		public static ConfigEntry<float> PrinterTierVoid2Weight;

		public static ConfigEntry<float> PrinterTierVoid3Weight;

		public static ConfigEntry<float> PrinterTierVoidBossWeight;

		public static ConfigEntry<float> PrinterTierVoidAnyWeight;

		public static ConfigEntry<bool> CauldronSectionEnabled;

		public static ConfigEntry<int> CauldronMaxAmount;

		public static ConfigEntry<int> CauldronDirectorCost;

		public static ConfigEntry<float> CauldronDirectorWeight;

		public static ConfigEntry<float> CauldronWhiteToGreenWeight;

		public static ConfigEntry<float> CauldronGreenToRedWeight;

		public static ConfigEntry<float> CauldronRedToWhiteWeight;

		public static ConfigEntry<int> CauldronWhiteToGreenCost;

		public static ConfigEntry<int> CauldronGreenToRedCost;

		public static ConfigEntry<int> CauldronRedToWhiteCost;

		public static ConfigEntry<float> CauldronTranscendentWeight;

		public static ConfigEntry<int> CauldronTranscendentCost;

		public static ConfigEntry<bool> ScrapperSectionEnabled;

		public static ConfigEntry<int> ScrapperMaxAmount;

		public static ConfigEntry<int> ScrapperDirectorCost;

		public static ConfigEntry<float> ScrapperDirectorWeight;

		public static ConfigEntry<bool> EquipmentSectionEnabled;

		public static ConfigEntry<int> EquipmentMaxAmount;

		public static ConfigEntry<int> EquipmentDirectorCost;

		public static ConfigEntry<float> EquipmentDirectorWeight;

		public static ConfigEntry<bool> EquipmentInstancedPurchases;

		public static ConfigEntry<int> EquipmentCost;

		public static ConfigEntry<CostTypeIndex> EquipmentCostType;

		public static ConfigEntry<bool> EquipmentBuyToInventory;

		public static ConfigEntry<bool> EquipmentReplaceLunarSeersWithEquipment;

		public static ConfigEntry<float> EquipmentReplaceWithEliteChance;

		public static ConfigEntry<string> EquipmentReplaceWithEliteList;

		public static ConfigEntry<bool> LunarShopSectionEnabled;

		public static ConfigEntry<int> LunarShopMaxAmount;

		public static ConfigEntry<int> LunarShopDirectorCost;

		public static ConfigEntry<float> LunarShopDirectorWeight;

		public static ConfigEntry<int> LunarShopCost;

		public static ConfigEntry<CostTypeIndex> LunarShopCostType;

		public static ConfigEntry<int> LunarShopBuyLimit;

		public static ConfigEntry<bool> LunarShopSequentialItems;

		public static ConfigEntry<string> LunarShopItemList;

		public static ConfigEntry<bool> LunarShopInstancedPurchases;

		public static ConfigEntry<bool> LunarShopBuyToInventory;

		public static ConfigEntry<string> LunarShopAmountDependingOnCharacter;

		public static Dictionary<BodyIndex, int> LunarShopAmountDependingOnCharacterParsed = new Dictionary<BodyIndex, int>();

		public static ConfigEntry<bool> LunarRecyclerSectionEnabled;

		public static ConfigEntry<bool> LunarRecyclerAvailable;

		public static ConfigEntry<int> LunarRecyclerCost;

		public static ConfigEntry<int> LunarRecyclerCostMultiplier;

		public static ConfigEntry<int> LunarRecyclerRerollLimit;

		public static ConfigEntry<bool> CleansingPoolSectionEnabled;

		public static ConfigEntry<bool> CleansingPoolRewardsLunarCoins;

		public static ConfigEntry<int> CleansingPoolDirectorCost;

		public static ConfigEntry<float> CleansingPoolDirectorWeight;

		public static ConfigEntry<bool> LunarSeerSectionEnabled;

		public static ConfigEntry<bool> LunarSeerAvailable;

		public static ConfigEntry<int> LunarSeerCost;

		public static ConfigEntry<bool> ShrineOfOrderSectionEnabled;

		public static ConfigEntry<int> ShrineOfOrderUseLimit;

		public static ConfigEntry<int> ShrineOfOrderCost;

		public static ConfigEntry<int> ShrineOfOrderDirectorCost;

		public static ConfigEntry<float> ShrineOfOrderDirectorWeight;

		public static ConfigEntry<bool> DonateSectionEnabled;

		public static ConfigEntry<int> DonateCost;

		public static ConfigEntry<CostTypeIndex> DonateCostType;

		public static ConfigEntry<int> DonateDirectorCost;

		public static ConfigEntry<float> DonateDirectorWeight;

		public static ConfigEntry<int> DonateRewardLimitPerVisit;

		public static ConfigEntry<int> DonateRewardLimitPerRun;

		public static ConfigEntry<bool> DonateSequentialRewardLists;

		public static ConfigEntry<float> DonateRewardList1Weight;

		public static ConfigEntry<string> DonateRewardList1;

		public static ConfigEntry<float> DonateRewardList2Weight;

		public static ConfigEntry<string> DonateRewardList2;

		public static ConfigEntry<float> DonateRewardList3Weight;

		public static ConfigEntry<string> DonateRewardList3;

		public static ConfigEntry<string> DonateRewardListAvailableCharacters;

		public static ConfigEntry<float> DonateRewardListCharacterWeight;

		public static ConfigEntry<string> DonateRewardListCharacterDefault;

		public static Dictionary<BodyIndex, ConfigEntry<string>> DonateRewardListCharacters = new Dictionary<BodyIndex, ConfigEntry<string>>();

		public static ConfigEntry<bool> WanderingChefSectionEnabled;

		public static ConfigEntry<bool> WanderingChefUnrestrictedCrafting;

		public static ConfigEntry<bool> WanderingChefCraftableRecipesOnly;

		public static ConfigEntry<bool> WanderingChefBuyToInventory;

		public static ConfigEntry<int> WanderingChefDirectorCost;

		public static ConfigEntry<float> WanderingChefDirectorWeight;

		public static ConfigEntry<bool> DronesSectionEnabled;

		public static ConfigEntry<int> DronesDroneCombinerStationDirectorCost;

		public static ConfigEntry<float> DronesDroneCombinerStationDirectorWeight;

		public static ConfigEntry<int> DronesDroneUpgradeStationDirectorCost;

		public static ConfigEntry<float> DronesDroneUpgradeStationDirectorWeight;

		public static ConfigEntry<int> DronesDroneScrapperDirectorCost;

		public static ConfigEntry<float> DronesDroneScrapperDirectorWeight;

		public static ConfigEntry<int> DronesTripleDroneShopDirectorCost;

		public static ConfigEntry<float> DronesTripleDroneShopDirectorWeight;

		public static ConfigEntry<float> DronesTripleDroneShopCommonWeight;

		public static ConfigEntry<float> DronesTripleDroneShopUncommonWeight;

		public static ConfigEntry<int> DronesTripleDroneShopCommonCost;

		public static ConfigEntry<int> DronesTripleDroneShopUncommonCost;

		public static ConfigEntry<CostTypeIndex> DronesTripleDroneShopCostType;

		public static ConfigEntry<bool> CommandPedestalSectionEnabled;

		public static ConfigEntry<float> CommandPedestalDirectorWeight;

		public static readonly List<CommandPedestalTier> CommandPedestalTiers = new List<CommandPedestalTier>();

		public static ConfigEntry<CostTypeIndex> CommandPedestalCostType;

		public static ConfigEntry<bool> CommandPedestalInstancedPurchases;

		public static ConfigEntry<bool> CommandPedestalBuyToInventory;

		private const string itemTiersString = "Tier1 | Tier2 | Tier3 | Lunar | Boss | VoidTier1 | VoidTier2 | VoidTier3 | VoidBoss | FoodTier";

		private const string itemKeyWordsExplanation = "Can use:\n - internal item names(see https://risk-of-thunder.github.io/R2Wiki/Mod-Creation/Developer-Reference/Items-and-Equipments-Data/)\n- item tier keywords (Tier1 | Tier2 | Tier3 | Lunar | Boss | VoidTier1 | VoidTier2 | VoidTier3 | VoidBoss | FoodTier)\n- droptable names (see README.md)\nFollows ItemStringParser format.";

		private static bool reloading;

		public static void InitConfig(ConfigFile config)
		{
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Expected O, but got Unknown
			//IL_052b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0535: Expected O, but got Unknown
			//IL_05ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b6: Expected O, but got Unknown
			//IL_06f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fe: Expected O, but got Unknown
			EnableMod = config.Bind<bool>("00 General", "Enabled", true, "Enable Mod");
			AlwaysSpawnShopPortal = config.Bind<bool>("00 General", "AlwaysSpawnShopPortal", false, "Spawn a portal to the Bazaar after each teleporter event.");
			DirectorExtraCredits = config.Bind<int>("00 General", "DirectorExtraCredits", 15, "Credits the director gets on every visit to the Bazaar, on top of DirectorCreditsPerStage. Like the game's scene director, it spends them at random on the sections' interactables, by their DirectorCost and DirectorWeight.");
			DirectorCreditsPerStage = config.Bind<int>("00 General", "DirectorCreditsPerStage", 25, "Credits the director gets for every stage cleared in the run.");
			DirectorCreditsCap = config.Bind<int>("00 General", "DirectorCreditsCap", 200, "The most credits the director gets on a visit, DirectorExtraCredits included. -1 = No cap.");
			ScaleMoneyCosts = config.Bind<bool>("00 General", "ScaleMoneyCosts", true, "Costs paid in Money scale with difficulty, like the game's own shops. E.g. an Equipment Terminal with Cost 50 then costs what the game's triple equipment shop costs.");
			PreventDrifterBagging = config.Bind<bool>("00 General", "PreventDrifterBagging", true, "Drifter can't put anything into his bag in the Bazaar: no interactables, no Newt, no other players or drones. The bag stays empty, like when he grabs something he can't carry.");
			PreventDrifterJunk = config.Bind<bool>("00 General", "PreventDrifterJunk", true, "Drifter gains no Junk in the Bazaar, so Salvage can't farm temporary items there or on the next stage. Junk brought into the Bazaar can still be used.");
			PreventDrifterTinker = config.Bind<bool>("00 General", "PreventDrifterTinker", true, "Drifter's Tinker changes nothing in the Bazaar: it doesn't reroll Lunar Buds, terminals or printers, and doesn't turn item pickups into scrap and temporary items. It causes issues together with Instanced Purchases.");
			NewtSectionEnabled = config.Bind<bool>("01 Newt", "SectionEnabled", true, "Enables or disables the Newt section.");
			NewtNoKickFromShop = config.Bind<bool>("01 Newt", "NoKickFromShop", true, "Prevents being kicked out of the Bazaar after angering Newt.");
			NewtDeathBehavior = config.Bind<ShopKeeper.DeathState>("01 Newt", "DeathBehavior", ShopKeeper.DeathState.Tank, "Determines Newt's behavior after death.\nDefault: Vanilla - Unchanged behavior\nTank: Doubles Newt's health after each kill\nGhost: Newt respawns as a passive ghost\nHostile: Newt revives hostile and attacks players");
			NewtKarmaTrigger = config.Bind<ShopKeeper.KarmaTrigger>("01 Newt", "KarmaTrigger", ShopKeeper.KarmaTrigger.OnKill, "When angering Newt raises the run's karma, if karma is enabled for the run.\nOnDamage: Vanilla - When he would kick you out after being hit, also if NoKickFromShop keeps you in\nOnKill: Only when he is killed");
			NewtKarmaTriggerOncePerVisit = config.Bind<bool>("01 Newt", "KarmaTriggerOncePerVisit", true, "Angering Newt raises the run's karma at most once per visit to the Bazaar, even if he revives and is angered again.");
			NewtDialogue = config.Bind<ShopKeeper.Dialogue>("01 Newt", "Dialogue", ShopKeeper.Dialogue.Default, "What Newt says in chat.\nOff: Nothing\nDefault: The game's own unused Newt lines when you donate, buy from a Lunar Bud or hit him, shown in each player's language. He also greets you, in English.\nBazaarIsMyHome: The greetings and remarks of the original BazaarIsMyHome mod, in the host's language");
			PrinterSectionEnabled = config.Bind<bool>("02 Printer", "SectionEnabled", true, "Enables or disables the Printer section.");
			PrinterMaxAmount = config.Bind<int>("02 Printer", "MaxAmount", 9, new ConfigDescription("Maximum number of printers the director can spawn (max 9).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 9), Array.Empty<object>()));
			PrinterDirectorCostWhite = config.Bind<int>("02 Printer", "DirectorCostWhite", 5, "Director credits a printer for white (Tier 1) items costs.");
			PrinterDirectorCostGreen = config.Bind<int>("02 Printer", "DirectorCostGreen", 10, "Director credits a printer for green (Tier 2) items costs.");
			PrinterDirectorCostRed = config.Bind<int>("02 Printer", "DirectorCostRed", 15, "Director credits a printer for red (Tier 3) or Void items costs.");
			PrinterDirectorCostBoss = config.Bind<int>("02 Printer", "DirectorCostBoss", 10, "Director credits a printer for Boss items costs.");
			PrinterDirectorWeight = config.Bind<float>("02 Printer", "DirectorWeight", 4f, "How likely the director picks a printer, compared to the DirectorWeight of the other interactables. Which tier it prints is rolled by the tier weights below.");
			PrinterTier1Weight = config.Bind<float>("02 Printer", "Tier1Weight", 0.5f, "Weight for Tier 1 (white) items.");
			PrinterTier2Weight = config.Bind<float>("02 Printer", "Tier2Weight", 0.25f, "Weight for Tier 2 (green) items.");
			PrinterTier3Weight = config.Bind<float>("02 Printer", "Tier3Weight", 0.17f, "Weight for Tier 3 (red) items.");
			PrinterTierBossWeight = config.Bind<float>("02 Printer", "BossWeight", 0.04f, "Weight for Boss-tier items.");
			PrinterTierVoid1Weight = config.Bind<float>("02 Printer", "TierVoid1Weight", 0.015f, "Weight for Tier 1 Void items (traded from red).");
			PrinterTierVoid2Weight = config.Bind<float>("02 Printer", "TierVoid2Weight", 0.015f, "Weight for Tier 2 Void items (traded from red).");
			PrinterTierVoid3Weight = config.Bind<float>("02 Printer", "TierVoid3Weight", 0.006f, "Weight for Tier 3 Void items (traded from red).");
			PrinterTierVoidBossWeight = config.Bind<float>("02 Printer", "TierVoidBossWeight", 0.003f, "Weight for Boss-tier Void items (traded from red).");
			PrinterTierVoidAnyWeight = config.Bind<float>("02 Printer", "TierVoidAnyWeight", 0f, "Weight for Void items of any tier (traded from red).");
			CauldronSectionEnabled = config.Bind<bool>("03 Cauldron", "SectionEnabled", true, "Enables or disables the Cauldron section.");
			CauldronMaxAmount = config.Bind<int>("03 Cauldron", "MaxAmount", 7, new ConfigDescription("Maximum number of cauldrons the director can spawn (max 7).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 7), Array.Empty<object>()));
			CauldronDirectorCost = config.Bind<int>("03 Cauldron", "DirectorCost", 10, "Director credits a cauldron costs.");
			CauldronDirectorWeight = config.Bind<float>("03 Cauldron", "DirectorWeight", 2f, "How likely the director picks a cauldron, compared to the DirectorWeight of the other interactables. Which type it is is rolled by the weights below.");
			CauldronWhiteToGreenWeight = config.Bind<float>("03 Cauldron", "WhiteToGreenWeight", 0.75f, "Weight for White->Green cauldrons.");
			CauldronWhiteToGreenCost = config.Bind<int>("03 Cauldron", "WhiteToGreenCost", 3, "Number of White items required for Green conversion.");
			CauldronGreenToRedWeight = config.Bind<float>("03 Cauldron", "GreenToRedWeight", 0.25f, "Weight for Green->Red cauldrons.");
			CauldronGreenToRedCost = config.Bind<int>("03 Cauldron", "GreenToRedCost", 5, "Number of Green items required for Red conversion.");
			CauldronRedToWhiteWeight = config.Bind<float>("03 Cauldron", "RedToWhiteWeight", 0f, "Weight for Red->White cauldrons.");
			CauldronRedToWhiteCost = config.Bind<int>("03 Cauldron", "RedToWhiteCost", 1, "Number of Red items required for White conversion.");
			CauldronTranscendentWeight = config.Bind<float>("03 Cauldron", "TranscendentWeight", 0f, "Weight for Transcendent Cauldrons from Hallowed Concepts, which turn a Hex into a cursed item. Only spawns if Hallowed Concepts is enabled for the run.");
			CauldronTranscendentCost = config.Bind<int>("03 Cauldron", "TranscendentCost", 1, "Number of Hexes a Transcendent Cauldron takes.");
			ScrapperSectionEnabled = config.Bind<bool>("04 Scrapper", "SectionEnabled", true, "Enables or disables the Scrapper section.");
			ScrapperMaxAmount = config.Bind<int>("04 Scrapper", "MaxAmount", 2, new ConfigDescription("Number of Scrappers spawned when the director picks them (max 2).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 2), Array.Empty<object>()));
			ScrapperDirectorCost = config.Bind<int>("04 Scrapper", "DirectorCost", 3, "Director credits the Scrappers cost. The director picks them only once, and then all of them spawn.");
			ScrapperDirectorWeight = config.Bind<float>("04 Scrapper", "DirectorWeight", 1f, "How likely the director picks the Scrappers, compared to the DirectorWeight of the other interactables.");
			EquipmentSectionEnabled = config.Bind<bool>("05 Equipment", "SectionEnabled", true, "Enables or disables the Equipment section.");
			EquipmentMaxAmount = config.Bind<int>("05 Equipment", "MaxAmount", 3, new ConfigDescription("Maximum number of Equipment Terminals the director can spawn (max 3 normally, 5 if replacing Lunar Seers).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 5), Array.Empty<object>()));
			EquipmentDirectorCost = config.Bind<int>("05 Equipment", "DirectorCost", 2, "Director credits an Equipment Terminal costs.");
			EquipmentDirectorWeight = config.Bind<float>("05 Equipment", "DirectorWeight", 1f, "How likely the director picks an Equipment Terminal, compared to the DirectorWeight of the other interactables.");
			EquipmentReplaceLunarSeersWithEquipment = config.Bind<bool>("05 Equipment", "ReplaceLunarSeersWithEquipment", false, "Replaces Lunar Seers with Equipment Terminals (increases equipment max to 5). Makes the Lunar Seer section irrelevant.");
			EquipmentReplaceWithEliteChance = config.Bind<float>("05 Equipment", "ReplaceWithEliteChance", 0.15f, "Chance for replacing the equipment with an elite equipment.");
			EquipmentReplaceWithEliteList = config.Bind<string>("05 Equipment", "ReplaceWithEliteList", "EliteEarthEquipment | EliteFireEquipment | EliteIceEquipment | EliteLunarEquipment | EliteLightningEquipment", "With which elite equipments to replace. List in the format equipment1 | equipment2. Can use:\\n- internal item names (see https://risk-of-thunder.github.io/R2Wiki/Mod-Creation/Developer-Reference/Items-and-Equipments-Data/)\\n- item tier keywords ({itemTiersString})\\n- droptable names (see README.md). Follows ItemStringParser format.");
			EquipmentCost = config.Bind<int>("05 Equipment", "Cost", 50, "Cost of an equipment purchase, paid in CostType.");
			EquipmentCostType = config.Bind<CostTypeIndex>("05 Equipment", "CostType", (CostTypeIndex)1, "What equipment purchases cost, e.g. Money, LunarCoin, WhiteItem or PercentHealth. The price sign shows it too. Money scales with difficulty if ScaleMoneyCosts is on.");
			EquipmentInstancedPurchases = config.Bind<bool>("05 Equipment", "InstancedPurchases", true, "Each player can purchase equipment independently.");
			EquipmentBuyToInventory = config.Bind<bool>("05 Equipment", "BuyToInventory", true, "Purchased equipment goes directly into inventory instead of dropping to the ground. Equipment replaced by a purchase goes into the terminal, where swapping again is free for the buyer.");
			LunarShopSectionEnabled = config.Bind<bool>("06 LunarShop", "SectionEnabled", true, "Enables or disables the Lunar Shop section.");
			LunarShopMaxAmount = config.Bind<int>("06 LunarShop", "MaxAmount", 5, new ConfigDescription("Maximum number of Lunar Buds the director can spawn (max 20).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 20), Array.Empty<object>()));
			LunarShopDirectorCost = config.Bind<int>("06 LunarShop", "DirectorCost", 0, "Director credits a Lunar Bud costs. With 0, all buds up to MaxAmount always spawn.");
			LunarShopDirectorWeight = config.Bind<float>("06 LunarShop", "DirectorWeight", 1f, "How likely the director picks a Lunar Bud, compared to the DirectorWeight of the other interactables.");
			string text = "Tonic | AutoCastEquipment | RandomDamageZone | LunarDagger | HalfSpeedDoubleHealth | ShieldOnly | ShieldOnly | ShieldOnly | LunarPrimaryReplacement | LunarSecondaryReplacement | LunarSpecialReplacement | LunarBadLuck | LunarBadLuck | LunarBadLuck | LunarSun | HalfAttackSpeedHalfCooldowns | HalfAttackSpeedHalfCooldowns";
			LunarShopItemList = config.Bind<string>("06 LunarShop", "ItemList", "dtLunarChest", "List of items available in Lunar Shop. Can use:\n - internal item names(see https://risk-of-thunder.github.io/R2Wiki/Mod-Creation/Developer-Reference/Items-and-Equipments-Data/)\n- item tier keywords (Tier1 | Tier2 | Tier3 | Lunar | Boss | VoidTier1 | VoidTier2 | VoidTier3 | VoidBoss | FoodTier)\n- droptable names (see README.md)\nFollows ItemStringParser format. Example: " + text);
			LunarShopSequentialItems = config.Bind<bool>("06 LunarShop", "SequentialItems", false, "Picks items sequentially from the list instead of randomly.");
			LunarShopCost = config.Bind<int>("06 LunarShop", "Cost", 2, "Cost of a Lunar Bud purchase, paid in CostType.");
			LunarShopCostType = config.Bind<CostTypeIndex>("06 LunarShop", "CostType", (CostTypeIndex)3, "What Lunar Bud purchases cost, e.g. LunarCoin, Money, WhiteItem or PercentHealth. The price tag shows it too. Money scales with difficulty if ScaleMoneyCosts is on.");
			LunarShopBuyLimit = config.Bind<int>("06 LunarShop", "BuyLimit", 5, "Limit on Lunar Shop purchases each player can make per visit to the Bazaar. -1 = Unlimited.");
			LunarShopInstancedPurchases = config.Bind<bool>("06 LunarShop", "InstancedPurchases", true, "Each player can buy independently from Lunar Shop.");
			LunarShopAmountDependingOnCharacter = config.Bind<string>("06 LunarShop", "AmountDependingOnCharacter", "", "Change the number of Lunar Buds by Character. Needs InstancedPurchases. Cannot exceed the number of spawned buds. Comma-separated <characterBody|survivorName>=<amount>.\nExample: Seeker=15, FalseSon=16");
			LunarShopBuyToInventory = config.Bind<bool>("06 LunarShop", "BuyToInventory", true, "Items go directly into inventory instead of dropping on ground. Equipment replaced by a purchase goes into the bud, where swapping again is free for the buyer.");
			LunarRecyclerSectionEnabled = config.Bind<bool>("07 LunarRecycler", "SectionEnabled", true, "Enables or disables the Lunar Recycler section.");
			LunarRecyclerAvailable = config.Bind<bool>("07 LunarRecycler", "Available", true, "If enabled, a Lunar Recycler is available in the Bazaar. Otherwise it will get removed. It is also removed when the director spawns no Lunar Buds.");
			LunarRecyclerCost = config.Bind<int>("07 LunarRecycler", "Cost", 1, "Initial lunar coin cost to reroll.");
			LunarRecyclerCostMultiplier = config.Bind<int>("07 LunarRecycler", "CostMultiplier", 2, "Cost multiplier applied after each reroll use.");
			LunarRecyclerRerollLimit = config.Bind<int>("07 LunarRecycler", "RerollLimit", 3, "Limit the amount of rerolls allowed per visit to the Bazaar. -1 = Unlimited.");
			CleansingPoolSectionEnabled = config.Bind<bool>("08 CleansingPool", "SectionEnabled", true, "Enables or disables the Cleansing Pool section.");
			CleansingPoolDirectorCost = config.Bind<int>("08 CleansingPool", "DirectorCost", 0, "Director credits the Cleansing Pool costs. Free by default, since with RewardsLunarCoin it only gives back a Lunar Coin, so it always spawns unless its DirectorWeight is 0. Vanilla value: 5.");
			CleansingPoolDirectorWeight = config.Bind<float>("08 CleansingPool", "DirectorWeight", 1f, "How likely the director picks the Cleansing Pool, compared to the DirectorWeight of the other interactables.");
			CleansingPoolRewardsLunarCoins = config.Bind<bool>("08 CleansingPool", "RewardsLunarCoin", true, "Cleansing Pools reward a Lunar Coin instead of a Pearl.");
			LunarSeerSectionEnabled = config.Bind<bool>("09 LunarSeer", "SectionEnabled", true, "Enables or disables the Lunar Seer Station section.");
			LunarSeerAvailable = config.Bind<bool>("09 LunarSeer", "Available", true, "If enabled, Seer Stations appear in the Bazaar.");
			LunarSeerCost = config.Bind<int>("09 LunarSeer", "Cost", 3, "Lunar coin cost for using Seer Stations.");
			ShrineOfOrderSectionEnabled = config.Bind<bool>("10 ShrineOfOrder", "SectionEnabled", true, "Enables or disables the Shrine of Order section. Enabling lets the director spawn a Shrine of Order near the Newt.");
			ShrineOfOrderDirectorCost = config.Bind<int>("10 ShrineOfOrder", "DirectorCost", 5, "Director credits the Shrine of Order costs.");
			ShrineOfOrderDirectorWeight = config.Bind<float>("10 ShrineOfOrder", "DirectorWeight", 1f, "How likely the director picks the Shrine of Order, compared to the DirectorWeight of the other interactables.");
			ShrineOfOrderCost = config.Bind<int>("10 ShrineOfOrder", "Cost", 1, "Lunar coin cost of each Shrine of Order use.");
			ShrineOfOrderUseLimit = config.Bind<int>("10 ShrineOfOrder", "UseLimit", -1, "Limit the amount of Shrine of Order uses per visit to the Bazaar. -1 = Unlimited.");
			DonateSectionEnabled = config.Bind<bool>("11 Donate", "SectionEnabled", true, "Enables or disables the Donate section. Enabling lets the director spawn a Donation Altar near the Newt.");
			DonateDirectorCost = config.Bind<int>("11 Donate", "DirectorCost", 10, "Director credits the Donation Altar costs.");
			DonateDirectorWeight = config.Bind<float>("11 Donate", "DirectorWeight", 1f, "How likely the director picks the Donation Altar, compared to the DirectorWeight of the other interactables.");
			DonateCost = config.Bind<int>("11 Donate", "Cost", 5, "Cost of a donation, paid in CostType.");
			DonateCostType = config.Bind<CostTypeIndex>("11 Donate", "CostType", (CostTypeIndex)3, "What a donation costs, e.g. LunarCoin, Money, WhiteItem or PercentHealth. The price tag shows it too. Money scales with difficulty if ScaleMoneyCosts is on.");
			DonateRewardLimitPerVisit = config.Bind<int>("11 Donate", "RewardLimitPerVisit", 1, "Limit the number of rewards each player can get per visit to the Bazaar.");
			DonateRewardLimitPerRun = config.Bind<int>("11 Donate", "RewardLimitPerRun", 1, "Limit the number of rewards each player can get in total over the course of the complete run. Must be equal or higher than RewardLimitPerVisit.");
			DonateSequentialRewardLists = config.Bind<bool>("11 Donate", "SequentialRewardLists", false, "If enabled, the reward lists will be choosen sequentially, ordered from heighest weight to lowest weight. The current reward list is stored for each player per run and swaps around. Reward lists with weight = 0 will be ignored.");
			DonateRewardList1Weight = config.Bind<float>("11 Donate", "RewardList1Weight", 0f, "Weight for choosing RewardList1.");
			DonateRewardList1 = config.Bind<string>("11 Donate", "RewardList1", "2xdtChest1 | Tier2", "Item reward pool. Format: <amount1>x<item1> & <amount2>x<item2>, or | to pick one. See README.md for more detailed description. Can use:\n - internal item names(see https://risk-of-thunder.github.io/R2Wiki/Mod-Creation/Developer-Reference/Items-and-Equipments-Data/)\n- item tier keywords (Tier1 | Tier2 | Tier3 | Lunar | Boss | VoidTier1 | VoidTier2 | VoidTier3 | VoidBoss | FoodTier)\n- droptable names (see README.md)\nFollows ItemStringParser format. Example: Hoof & Tier1");
			DonateRewardList2Weight = config.Bind<float>("11 Donate", "RewardList2Weight", 0f, "Weight for choosing RewardList2.");
			DonateRewardList2 = config.Bind<string>("11 Donate", "RewardList2", "Tier3 | Boss", "Item reward pool. Format: <amount1>x<item1> & <amount2>x<item2>, or | to pick one. See README.md for more detailed description. Can use:\n - internal item names(see https://risk-of-thunder.github.io/R2Wiki/Mod-Creation/Developer-Reference/Items-and-Equipments-Data/)\n- item tier keywords (Tier1 | Tier2 | Tier3 | Lunar | Boss | VoidTier1 | VoidTier2 | VoidTier3 | VoidBoss | FoodTier)\n- droptable names (see README.md)\nFollows ItemStringParser format. Example: AlienHead | 2xTier2");
			DonateRewardList3Weight = config.Bind<float>("11 Donate", "RewardList3Weight", 0f, "Weight for choosing RewardList3.");
			DonateRewardList3 = config.Bind<string>("11 Donate", "RewardList3", "10xBoostAttackSpeed | 10xBoostDamage | 10xBoostEquipmentRecharge | 10xBoostHp | 10xCrippleWardOnLevel | EmpowerAlways | Ghost | 3xIncubator | 10xLevelBonus | 10xWarCryOnCombat | 10xTempestOnKill", "Item reward pool. Format: <amount1>x<item1> & <amount2>x<item2>, or | to pick one. See README.md for more detailed description. Can use:\n - internal item names(see https://risk-of-thunder.github.io/R2Wiki/Mod-Creation/Developer-Reference/Items-and-Equipments-Data/)\n- item tier keywords (Tier1 | Tier2 | Tier3 | Lunar | Boss | VoidTier1 | VoidTier2 | VoidTier3 | VoidBoss | FoodTier)\n- droptable names (see README.md)\nFollows ItemStringParser format.");
			DonateRewardListCharacterWeight = config.Bind<float>("11 Donate", "RewardListCharacterWeight", 1f, "Weight for choosing the reward list of the respective character.");
			string[] value = SurvivorCatalog.allSurvivorDefs.Select((SurvivorDef survivor) => survivor.cachedName).ToArray();
			DonateRewardListAvailableCharacters = config.Bind<string>("11 Donate", "RewardListAvailableCharacters", string.Join(", ", value), "Available special reward lists for certain characters. Applies only if the donator is a character of the respective type. Comma-separated list of characters (see README.md)");
			DonateRewardListCharacterDefault = config.Bind<string>("11 Donate", "RewardListCharacterDefault", "3xScrapGreen", "Item reward pool for characters without a reward list of their own, or whose list gives no reward. Format: <amount1>x<item1> & <amount2>x<item2>, or | to pick one. See README.md for more detailed description. Can use:\n - internal item names(see https://risk-of-thunder.github.io/R2Wiki/Mod-Creation/Developer-Reference/Items-and-Equipments-Data/)\n- item tier keywords (Tier1 | Tier2 | Tier3 | Lunar | Boss | VoidTier1 | VoidTier2 | VoidTier3 | VoidBoss | FoodTier)\n- droptable names (see README.md)\nFollows ItemStringParser format.");
			WanderingChefSectionEnabled = config.Bind<bool>("12 WanderingChef", "SectionEnabled", true, "Enables or disables the Wandering Chef section. Only works if the Alloyed Collective is enabled for the run. Enabling lets the director spawn a Wandering Chef near the Lunar Shop.");
			WanderingChefDirectorCost = config.Bind<int>("12 WanderingChef", "DirectorCost", 7, "Director credits the Wandering Chef costs.");
			WanderingChefDirectorWeight = config.Bind<float>("12 WanderingChef", "DirectorWeight", 0.5f, "How likely the director picks the Wandering Chef, compared to the DirectorWeight of the other interactables.");
			WanderingChefUnrestrictedCrafting = config.Bind<bool>("12 WanderingChef", "UnrestrictedCrafting", false, "Allows you to craft anything. Otherwise crafting is restricted to a single randomly selected target pickup.");
			WanderingChefCraftableRecipesOnly = config.Bind<bool>("12 WanderingChef", "CraftableRecipesOnly", true, "Only if UnrestrictedCrafting is false: The Wandering Chef only offers a recipe that a player can cook from their inventory and what the Bazaar offers (items in printers, Lunar Buds, Equipment Terminals and cauldrons, scrap if there are Scrappers, and one item from the Command Pedestal's choices). If there is none, he leaves and the director spends his credits on something else.");
			WanderingChefBuyToInventory = config.Bind<bool>("12 WanderingChef", "BuyToInventory", true, "Items go directly into inventory instead of dropping on ground. Cooked equipment replaces yours once your slots are full, and the old one is discarded.");
			DronesSectionEnabled = config.Bind<bool>("13 Drones", "SectionEnabled", true, "Enables or disables the Drones section. Only works if the Alloyed Collective is enabled for the run. Enabling lets the director spawn the drone stations below, and the players' drones come along into the Bazaar like on any other stage.");
			DronesDroneCombinerStationDirectorCost = config.Bind<int>("13 Drones", "DroneCombinerStationDirectorCost", 1, "Director credits the Drone Combiner Station costs.");
			DronesDroneCombinerStationDirectorWeight = config.Bind<float>("13 Drones", "DroneCombinerStationDirectorWeight", 1f, "How likely the director picks the Drone Combiner Station, compared to the DirectorWeight of the other interactables. 0 = never spawns.");
			DronesDroneUpgradeStationDirectorCost = config.Bind<int>("13 Drones", "DroneUpgradeStationDirectorCost", 5, "Director credits the Drone Upgrade Station costs.");
			DronesDroneUpgradeStationDirectorWeight = config.Bind<float>("13 Drones", "DroneUpgradeStationDirectorWeight", 1f, "How likely the director picks the Drone Upgrade Station, compared to the DirectorWeight of the other interactables. 0 = never spawns.");
			DronesDroneScrapperDirectorCost = config.Bind<int>("13 Drones", "DroneScrapperDirectorCost", 3, "Director credits the Drone Scrapper costs.");
			DronesDroneScrapperDirectorWeight = config.Bind<float>("13 Drones", "DroneScrapperDirectorWeight", 1f, "How likely the director picks the Drone Scrapper, compared to the DirectorWeight of the other interactables. 0 = never spawns.");
			DronesTripleDroneShopDirectorCost = config.Bind<int>("13 Drones", "TripleDroneShopDirectorCost", 8, "Director credits the Triple Drone Shop costs.");
			DronesTripleDroneShopDirectorWeight = config.Bind<float>("13 Drones", "TripleDroneShopDirectorWeight", 1f, "How likely the director picks the Triple Drone Shop, compared to the DirectorWeight of the other interactables. 0 = never spawns.");
			DronesTripleDroneShopCommonWeight = config.Bind<float>("13 Drones", "TripleDroneShopCommonWeight", 0.8f, "How likely the Triple Drone Shop offers common drones, compared to TripleDroneShopUncommonWeight. Unlike on other stages, where the game offers only common drones before the third stage, this applies on every visit.");
			DronesTripleDroneShopUncommonWeight = config.Bind<float>("13 Drones", "TripleDroneShopUncommonWeight", 0.2f, "How likely the Triple Drone Shop offers uncommon drones, compared to TripleDroneShopCommonWeight. 0 = never.");
			DronesTripleDroneShopCommonCost = config.Bind<int>("13 Drones", "TripleDroneShopCommonCost", 40, "Cost of a common drone from the Triple Drone Shop, paid in TripleDroneShopCostType.");
			DronesTripleDroneShopUncommonCost = config.Bind<int>("13 Drones", "TripleDroneShopUncommonCost", 60, "Cost of an uncommon drone from the Triple Drone Shop, paid in TripleDroneShopCostType.");
			DronesTripleDroneShopCostType = config.Bind<CostTypeIndex>("13 Drones", "TripleDroneShopCostType", (CostTypeIndex)1, "What a drone from the Triple Drone Shop costs, e.g. Money, LunarCoin, WhiteItem or PercentHealth. The price tag shows it too. Money scales with difficulty if ScaleMoneyCosts is on.");
			CommandPedestalSectionEnabled = config.Bind<bool>("14 CommandPedestal", "SectionEnabled", true, "Enables or disables the Command Pedestal section. It lets you pick an item for a price.");
			CommandPedestalDirectorWeight = config.Bind<float>("14 CommandPedestal", "DirectorWeight", 0.2f, "How likely the director picks the Command Pedestal, compared to the DirectorWeight of the other interactables. Which tier it offers is rolled by the tier weights below.");
			CommandPedestalTiers.Clear();
			AddCommandPedestalTier(config, "Tier1", "white items", (Run run) => run.availableTier1DropList, 50, 10, 0.5f);
			AddCommandPedestalTier(config, "Tier2", "green items", (Run run) => run.availableTier2DropList, 100, 20, 0.25f);
			AddCommandPedestalTier(config, "Tier3", "red items", (Run run) => run.availableTier3DropList, 800, 30, 0.05f);
			AddCommandPedestalTier(config, "Boss", "boss items", (Run run) => run.availableBossDropList, 400, 20, 0.05f);
			AddCommandPedestalTier(config, "Equipment", "equipment", (Run run) => run.availableEquipmentDropList, 100, 10, 0.125f);
			AddCommandPedestalTier(config, "Lunar", "lunar items", (Run run) => run.availableLunarItemDropList, 100, 20, 0f);
			AddCommandPedestalTier(config, "VoidTier1", "void white items", (Run run) => run.availableVoidTier1DropList, 50, 10, 0.05f);
			AddCommandPedestalTier(config, "VoidTier2", "void green items", (Run run) => run.availableVoidTier2DropList, 100, 20, 0.025f);
			AddCommandPedestalTier(config, "VoidTier3", "void red items", (Run run) => run.availableVoidTier3DropList, 800, 30, 0.0125f);
			AddCommandPedestalTier(config, "VoidBoss", "void boss items", (Run run) => run.availableVoidBossDropList, 400, 20, 0f);
			CommandPedestalCostType = config.Bind<CostTypeIndex>("14 CommandPedestal", "CostType", (CostTypeIndex)1, "What opening the Command Pedestal costs, e.g. Money, LunarCoin, WhiteItem or PercentHealth. The price tag shows it too. Money scales with difficulty if ScaleMoneyCosts is on.");
			CommandPedestalInstancedPurchases = config.Bind<bool>("14 CommandPedestal", "InstancedPurchases", true, "Each player can buy from the Command Pedestal once, independently of the others. It stays ready for the others, and each buyer gets their own Command Essence.");
			CommandPedestalBuyToInventory = config.Bind<bool>("14 CommandPedestal", "BuyToInventory", true, "Using the Command Pedestal shows its item picker right away, and the price is only charged once you pick an item, which goes directly into your inventory. Equipment it replaces goes into the vault, where only you can swap it back, for free. No essence appears; closing the picker costs nothing, and using the Command Pedestal again reopens it. Otherwise buying drops a Command Essence that anyone can use.");
			RefreshDerivedData(config);
			LunarShopAmountDependingOnCharacter.SettingChanged += LunarShopCharacterAmountsChanged;
			DonateRewardListAvailableCharacters.SettingChanged += DonationCharactersChanged;
			if (ModCompatibilityInLobbyConfig.enabled)
			{
				ModCompatibilityInLobbyConfig.CreateFromBepInExConfigFile(config, "BazaarIsMyHaven");
			}
		}

		public static void ReloadConfig(ConfigFile config)
		{
			bool saveOnConfigSet = config.SaveOnConfigSet;
			reloading = true;
			try
			{
				config.SaveOnConfigSet = false;
				config.Reload();
			}
			catch (Exception arg)
			{
				Log.LogError($"Could not reload the config: {arg}");
			}
			finally
			{
				config.SaveOnConfigSet = saveOnConfigSet;
				reloading = false;
			}
			RefreshDerivedData(config);
		}

		private static void AddCommandPedestalTier(ConfigFile config, string name, string offers, Func<Run, List<PickupIndex>> dropList, int cost, int directorCost, float weight)
		{
			CommandPedestalTiers.Add(new CommandPedestalTier
			{
				name = name,
				dropList = dropList,
				directorCost = config.Bind<int>("14 CommandPedestal", name + "DirectorCost", directorCost, "Director credits a Command Pedestal offering " + offers + " costs."),
				weight = config.Bind<float>("14 CommandPedestal", name + "Weight", weight, "Weight for a Command Pedestal offering " + offers + ", compared to the other tier weights. 0 = never."),
				cost = config.Bind<int>("14 CommandPedestal", name + "Cost", cost, "Cost of a Command Pedestal offering " + offers + ", paid in CostType.")
			});
		}

		private static void RefreshDerivedData(ConfigFile config)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Invalid comparison between Unknown and I4
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Invalid comparison between Unknown and I4
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Invalid comparison between Unknown and I4
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Invalid comparison between Unknown and I4
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Invalid comparison between Unknown and I4
			if (EquipmentMaxAmount.Value > 3 && !EquipmentReplaceLunarSeersWithEquipment.Value)
			{
				EquipmentMaxAmount.Value = 3;
			}
			if (EquipmentMaxAmount.Value > 5 && EquipmentReplaceLunarSeersWithEquipment.Value)
			{
				EquipmentMaxAmount.Value = 5;
			}
			if ((int)EquipmentCostType.Value >= 19)
			{
				EquipmentCostType.Value = (CostTypeIndex)1;
			}
			if ((int)LunarShopCostType.Value >= 19)
			{
				LunarShopCostType.Value = (CostTypeIndex)3;
			}
			if ((int)DonateCostType.Value >= 19)
			{
				DonateCostType.Value = (CostTypeIndex)3;
			}
			if ((int)CommandPedestalCostType.Value >= 19)
			{
				CommandPedestalCostType.Value = (CostTypeIndex)1;
			}
			if ((int)DronesTripleDroneShopCostType.Value >= 19)
			{
				DronesTripleDroneShopCostType.Value = (CostTypeIndex)1;
			}
			RefreshLunarShopCharacterAmounts();
			RefreshDonationRewardLists(config);
		}

		private static void LunarShopCharacterAmountsChanged(object sender, EventArgs args)
		{
			if (!reloading)
			{
				RefreshLunarShopCharacterAmounts();
			}
		}

		private static void DonationCharactersChanged(object sender, EventArgs args)
		{
			if (!reloading)
			{
				RefreshDonationRewardLists(((ConfigEntryBase)DonateRewardListAvailableCharacters).ConfigFile);
			}
		}

		private static void RefreshLunarShopCharacterAmounts()
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Invalid comparison between Unknown and I4
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			LunarShopAmountDependingOnCharacterParsed.Clear();
			if (string.IsNullOrWhiteSpace(LunarShopAmountDependingOnCharacter.Value))
			{
				return;
			}
			string[] array = LunarShopAmountDependingOnCharacter.Value.Split(",");
			foreach (string text in array)
			{
				string[] array2 = text.Split("=");
				if (array2.Length != 2)
				{
					Log.LogWarning("Could not parse character string " + text + " for AmountDependingOnCharacter");
					continue;
				}
				string text2 = array2[0].Trim();
				string text3 = array2[1].Trim();
				if (int.TryParse(text3, out var result))
				{
					if (string.IsNullOrWhiteSpace(text2))
					{
						Log.LogWarning("Could not parse character string name in " + text + " for AmountDependingOnCharacter");
						continue;
					}
					BodyIndex val = CatalogHelper.FindBody(text2);
					if ((int)val == -1)
					{
						Log.LogError("AmountDependingOnCharacter: Could not find body or survivor: " + text2);
					}
					else
					{
						LunarShopAmountDependingOnCharacterParsed[val] = result;
					}
				}
				else
				{
					Log.LogWarning("Could not parse character string amount " + text3 + " in " + text + " for AmountDependingOnCharacter");
				}
			}
		}

		private static void RefreshDonationRewardLists(ConfigFile config)
		{
			//IL_003c: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			DonateRewardListCharacters.Clear();
			string[] array = DonateRewardListAvailableCharacters.Value.Split(",");
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (!string.IsNullOrWhiteSpace(text))
				{
					BodyIndex val = CatalogHelper.FindBody(text);
					if ((int)val == -1)
					{
						Log.LogError("RewardListAvailableCharacters: Could not find body or survivor: " + text);
						continue;
					}
					ConfigEntry<string> value = config.Bind<string>("11 Donate", "RewardList" + text, text switch
					{
						"Bandit2" => "BleedOnHitAndExplode", 
						"Captain" => "3xBleedOnHit", 
						"Commando" => "5xStickyBomb", 
						"Croco" => "TriggerEnemyDebuffs", 
						"Engi" => "HealingPotion", 
						"Heretic" => "2xHealWhileSafe", 
						"Huntress" => "2xAttackSpeedOnCrit", 
						"Loader" => "2xIceRing", 
						"Mage" => "StrengthenBurn", 
						"Merc" => "AlienHead", 
						"Toolbot" => "5xSecondarySkillMagazine", 
						"Treebot" => "3xMedkit", 
						"Railgunner" => "CritDamage", 
						"VoidSurvivor" => "3xSlowOnHitVoid", 
						"Chef" => "5xAttackSpeedPerNearbyAllyOrEnemy", 
						"FalseSon" => "3xInfusion", 
						"Seeker" => "5xArmorPlate", 
						"DroneTech" => "3xBarrierOnCooldown", 
						"Drifter" => "SpeedOnPickup", 
						"Acolyte" => "2xSeed", 
						"Enforcer2" => "3xBarrierOnKill", 
						_ => "3xScrapGreen", 
					}, "Item reward pool for " + text + " in the format <amount1>x<item1> & <amount2>x<item2>. See README.md for more detailed description. Can use:\n - internal item names(see https://risk-of-thunder.github.io/R2Wiki/Mod-Creation/Developer-Reference/Items-and-Equipments-Data/)\n- item tier keywords (Tier1 | Tier2 | Tier3 | Lunar | Boss | VoidTier1 | VoidTier2 | VoidTier3 | VoidBoss | FoodTier)\n- droptable names (see README.md)\nFollows ItemStringParser format.");
					DonateRewardListCharacters[val] = value;
				}
			}
		}
	}
	public class SpawnCardStruct
	{
		public Vector3 Position { get; set; }

		public Vector3 Rotation { get; set; }

		public Vector3? Scale { get; set; }

		public SpawnCardStruct(Vector3 position, Vector3 rotation, Vector3? scale = null)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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)
			Position = position;
			Rotation = rotation;
			Scale = (Vector3)(((??)scale) ?? new Vector3(1f, 1f, 1f));
		}
	}
	public class PlayerStruct
	{
		public PlayerCharacterMasterController Master { get; set; }

		public int RewardCount { get; set; }

		public int LunarShopUseCount { get; set; }

		public PlayerStruct(PlayerCharacterMasterController master)
		{
			Master = master;
			RewardCount = 0;
			LunarShopUseCount = 0;
		}
	}
	public class ItemRewardStruct
	{
		public PickupIndex Pickup { get; set; }

		public int Count { get; set; }

		public bool IsUsed { get; set; }

		public ItemRewardStruct(PickupIndex pickup, int count, bool isUsed = false)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Pickup = pickup;
			Count = count;
			IsUsed = isUsed;
		}
	}
	public class ShopKeeper
	{
		public enum DeathState
		{
			Default,
			Tank,
			Ghost,
			Hostile
		}

		public enum Dialogue
		{
			Off,
			Default,
			BazaarIsMyHome
		}

		public enum KarmaTrigger
		{
			OnDamage,
			OnKill
		}

		public static bool DiedAtLeastOnce { get; set; }

		public static int DeathCount { get; set; }

		public static CharacterBody Body { get; set; }
	}
}