using System;
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.Configuration;
using BepInEx.Logging;
using HG.Reflection;
using Microsoft.CodeAnalysis;
using On.RoR2;
using On.RoR2.Networking;
using R2API.Networking;
using R2API.Networking.Interfaces;
using RoR2;
using RoR2.Artifacts;
using RoR2.Networking;
using RoR2.UI;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
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("CatchupLoot")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+54de05d8639907e57a333aaccea732a1ae8f557e")]
[assembly: AssemblyProduct("CatchupLoot")]
[assembly: AssemblyTitle("CatchupLoot")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 CatchupLoot
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("zerocodehero.CatchupLoot", "CatchupLoot", "2.2.0")]
	public class CatchupLootPlugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_GetExpAdjustedDropChancePercent <0>__Util_GetExpAdjustedDropChancePercent;

			public static NetworkMessageDelegate <1>__HandlePickupMessage;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_DropRewards <>9__40_0;

			public static Func<PlayerCharacterMasterController, bool> <>9__56_0;

			internal void <OnEnable>b__40_0(orig_DropRewards orig, BossGroup self)
			{
				if (EnablePlayerDropRateScaling.Value && IsModHooked)
				{
					self.scaleRewardsByPlayerCount = false;
				}
				orig.Invoke(self);
			}

			internal bool <GetPlayerCount>b__56_0(PlayerCharacterMasterController pc)
			{
				return pc.isConnected;
			}
		}

		public const string PluginGUID = "zerocodehero.CatchupLoot";

		public const string PluginAuthor = "zerocodehero";

		public const string PluginName = "CatchupLoot";

		public const string PluginVersion = "2.2.0";

		public static float dropChance = 5f;

		private static bool IsModHooked = false;

		private bool forceDisabled;

		private static bool useManualDropRate = false;

		private static DropRateManager dropRateManager;

		private static ConfigEntry<float> DropChanceMultiplier { get; set; }

		private static ConfigEntry<float> MinimumDropChance { get; set; }

		private static ConfigEntry<float> BaseDropChance { get; set; }

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

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

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

		private static ConfigEntry<KeyCode> PullItemsHotKey { get; set; }

		public void Awake()
		{
			Log.Init(((BaseUnityPlugin)this).Logger);
			DropChanceMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("General", "DropChanceMultiplier", 1f, "Manipulate drop rate. Use `0.5` to halve or `2` to double.");
			MinimumDropChance = ((BaseUnityPlugin)this).Config.Bind<float>("General", "MinimumDropChance", 1f, "The lowest possible drop chance when player count scaling is active.");
			EnablePlayerDropRateScaling = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnablePlayerBasedDropRateScaling", true, "Enabling this will reduce drop rates to account for shared loot.");
			EnableSwarmsScaling = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableSwarmsScaling", true, "Enabling this will (correctly) reduce drop rates for Artifact of Swarms.");
			EnableBadLuckProtection = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableBadLuckProtection", true, "Enabling this will increase drop rate consistency with low drop rates.");
			PullItemsHotKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("General", "PullItemsHotkey", (KeyCode)284, "Hotkey to use to pull items to yourself.");
			BaseDropChance = ((BaseUnityPlugin)this).Config.Bind<float>("General", "BaseDropChance", 5f, "Base item drop chance. It is recommended to leave this at the default value.");
			dropChance = BaseDropChance.Value;
			dropRateManager = new DropRateManager(EnableBadLuckProtection, EnableSwarmsScaling, DropChanceMultiplier, BaseDropChance, MinimumDropChance);
			Log.Info("CatchupLoot loaded");
		}

		private void Update()
		{
			//IL_0005: 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_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_008c: 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_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)
			if (!Input.GetKeyDown(PullItemsHotKey.Value) || !IsModHooked)
			{
				return;
			}
			try
			{
				Object.FindObjectsOfType<RuleBookViewer>();
				PickupDisplay[] array = Object.FindObjectsOfType<PickupDisplay>();
				Vector3 position = ((MPEventSystem)EventSystem.current).localUser.cachedMaster.GetBodyObject().transform.position;
				float num = 10f;
				Vector3 position2 = default(Vector3);
				for (int i = 0; i < array.Length; i++)
				{
					PickupDisplay val = array[i];
					if (((Object)val.highlight).name.StartsWith("CommandCube"))
					{
						float num2 = (float)i * MathF.PI * 2f / (float)array.Length;
						((Vector3)(ref position2))..ctor(position.x + Mathf.Cos(num2) * num, position.y, position.z + Mathf.Sin(num2) * num);
						((Component)val).gameObject.transform.position = position2;
					}
				}
			}
			catch (NullReferenceException)
			{
				((BaseUnityPlugin)this).Logger.LogDebug((object)"Failed to pull CommandCubes with F3 - most likely because there were none.");
			}
		}

		private void OnApplicationFocus(bool hasFocus)
		{
			if (hasFocus)
			{
				ReevaluateLifecycle();
			}
		}

		private void OnEnable()
		{
			//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_001f: Expected O, but got Unknown
			object obj = <>c.<>9__40_0;
			if (obj == null)
			{
				hook_DropRewards val = delegate(orig_DropRewards orig, BossGroup self)
				{
					if (EnablePlayerDropRateScaling.Value && IsModHooked)
					{
						self.scaleRewardsByPlayerCount = false;
					}
					orig.Invoke(self);
				};
				<>c.<>9__40_0 = val;
				obj = (object)val;
			}
			BossGroup.DropRewards += (hook_DropRewards)obj;
			SceneManager.activeSceneChanged += delegate(Scene oldScene, Scene newScene)
			{
				bool flag = ((Scene)(ref newScene)).name == "loadingbasic" || ((Scene)(ref newScene)).name == "intro" || ((Scene)(ref newScene)).name == "splash" || ((Scene)(ref newScene)).name == "title" || ((Scene)(ref newScene)).name == "eclipseworld" || ((Scene)(ref newScene)).name == "infinitetowerworld" || ((Scene)(ref newScene)).name == "lobby";
				forceDisabled = ((Scene)(ref newScene)).name == "artifactworld" || flag;
				if (flag)
				{
					useManualDropRate = false;
					DropRateTracker.ResetTracker();
				}
				ReevaluateLifecycle();
			};
			NetworkingAPI.RegisterMessageType<SpawnCustomMessage2>();
		}

		private void ReevaluateLifecycle()
		{
			if (EnablePlayerDropRateScaling.Value && IsSacrificeEnabled() && !useManualDropRate)
			{
				dropChance = dropRateManager.GetPlayerAwareBaseDropChance(GetPlayerCount(), dropChance);
			}
			if (forceDisabled)
			{
				if (IsModHooked)
				{
					Log.Warning("Force Disabled: Will remove hooks, even if Artifact of Command is enabled.");
					UnHook();
				}
				else
				{
					Log.Debug("Force Disabled: Will not hook.");
				}
				return;
			}
			bool flag = IsCommandEnabled();
			if (IsModHooked && !flag)
			{
				UnHook();
			}
			else if (!IsModHooked && flag)
			{
				Hook();
			}
		}

		private void Hook()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//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_002b: Expected O, but got Unknown
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loading hooks");
			object obj = <>O.<0>__Util_GetExpAdjustedDropChancePercent;
			if (obj == null)
			{
				hook_GetExpAdjustedDropChancePercent val = Util_GetExpAdjustedDropChancePercent;
				<>O.<0>__Util_GetExpAdjustedDropChancePercent = val;
				obj = (object)val;
			}
			Util.GetExpAdjustedDropChancePercent += (hook_GetExpAdjustedDropChancePercent)obj;
			NetworkMessageHandlerAttribute.RegisterClientMessages += new hook_RegisterClientMessages(NetworkMessageHandlerAttribute_RegisterClientMessages);
			PickupDropletController.CreateCommandCube += new hook_CreateCommandCube(PickupDropletController_CreateCommandCube);
			Interactor.AttemptInteraction += new hook_AttemptInteraction(Interactor_AttemptInteraction);
			PickupPickerController.SubmitChoice += new hook_SubmitChoice(PickupPickerController_SubmitChoice);
			GenericPickupController.CreatePickup += new hook_CreatePickup(GenericPickupController_CreatePickup);
			IsModHooked = true;
		}

		private void UnHook()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//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_002b: Expected O, but got Unknown
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Unloading hooks");
			object obj = <>O.<0>__Util_GetExpAdjustedDropChancePercent;
			if (obj == null)
			{
				hook_GetExpAdjustedDropChancePercent val = Util_GetExpAdjustedDropChancePercent;
				<>O.<0>__Util_GetExpAdjustedDropChancePercent = val;
				obj = (object)val;
			}
			Util.GetExpAdjustedDropChancePercent -= (hook_GetExpAdjustedDropChancePercent)obj;
			NetworkMessageHandlerAttribute.RegisterClientMessages -= new hook_RegisterClientMessages(NetworkMessageHandlerAttribute_RegisterClientMessages);
			PickupDropletController.CreateCommandCube -= new hook_CreateCommandCube(PickupDropletController_CreateCommandCube);
			Interactor.AttemptInteraction -= new hook_AttemptInteraction(Interactor_AttemptInteraction);
			PickupPickerController.SubmitChoice -= new hook_SubmitChoice(PickupPickerController_SubmitChoice);
			GenericPickupController.CreatePickup -= new hook_CreatePickup(GenericPickupController_CreatePickup);
			IsModHooked = false;
		}

		private GenericPickupController GenericPickupController_CreatePickup(orig_CreatePickup orig, ref CreatePickupInfo createPickupInfo)
		{
			return null;
		}

		private void PickupPickerController_SubmitChoice(orig_SubmitChoice orig, PickupPickerController self, int choiceIndex)
		{
			//IL_0031: 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_0071: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			if ((ulong)choiceIndex >= (ulong)self.options.Length)
			{
				return;
			}
			ref Option reference = ref self.options[choiceIndex];
			if (reference.available)
			{
				PickupIndexUnityEvent onPickupSelected = self.onPickupSelected;
				if (onPickupSelected != null)
				{
					((UnityEvent<int>)(object)onPickupSelected).Invoke(((Option)(ref reference)).pickupIndex.value);
					Log.Info($"Sending CreatePickup {((Option)(ref self.options[choiceIndex])).pickupIndex}");
					NetMessageExtensions.Send((INetMessage)(object)new SpawnCustomMessage2(((Option)(ref self.options[choiceIndex])).pickupIndex, ((MPEventSystem)EventSystem.current).localUser.cachedMaster.GetBodyObject().transform.position), (NetworkDestination)2);
					self.OnDisplayEnd((NetworkUIPromptController)null, (LocalUser)null, (CameraRigController)null);
					Object.Destroy((Object)(object)((Component)self).gameObject);
				}
			}
		}

		private void Interactor_AttemptInteraction(orig_AttemptInteraction orig, Interactor self, GameObject interactableObject)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (((Object)interactableObject).name.StartsWith("CommandCube"))
			{
				interactableObject.GetComponent<PickupPickerController>().OnDisplayBegin((NetworkUIPromptController)null, (LocalUser)null, ((MPEventSystem)EventSystem.current).localUser.cameraRigController);
			}
			else
			{
				orig.Invoke(self, interactableObject);
			}
		}

		private void PickupDropletController_CreateCommandCube(orig_CreateCommandCube orig, PickupDropletController self)
		{
			//IL_0001: 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_0021: 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_00c0: 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_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_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: 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_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: 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_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			DropRateTracker.RegisterItemDrop(self.createPickupInfo);
			NetworkServer.SendToAll((short)969, (MessageBase)(object)new SpawnCustomMessage
			{
				position = self.createPickupInfo.position,
				pickupIndex = ((CreatePickupInfo)(ref self.createPickupInfo)).pickupIndex
			});
			if (!NetworkServer.active)
			{
				return;
			}
			ReadOnlyCollection<NetworkUser> readOnlyInstancesList = NetworkUser.readOnlyInstancesList;
			if (readOnlyInstancesList == null)
			{
				return;
			}
			Vector3 val = default(Vector3);
			foreach (NetworkUser item in readOnlyInstancesList)
			{
				if ((Object)(object)item == (Object)null || ((NetworkBehaviour)item).connectionToClient == null || !((NetworkBehaviour)item).connectionToClient.isReady || (Object)(object)item.master == (Object)null || !item.master.hasBody)
				{
					continue;
				}
				ItemTier? catchupTier = PlayerCatchupManager.GetCatchupTier(item);
				if (!catchupTier.HasValue)
				{
					continue;
				}
				int deficit = PlayerCatchupManager.GetDeficit(item, catchupTier.Value);
				float catchupChance = PlayerCatchupManager.GetCatchupChance(deficit, catchupTier.Value);
				if (Random.value < catchupChance)
				{
					PickupIndex randomPickupForTier = PlayerCatchupManager.GetRandomPickupForTier(catchupTier.Value);
					if (((PickupIndex)(ref randomPickupForTier)).isValid)
					{
						((Vector3)(ref val))..ctor(Random.Range(-1.5f, 1.5f), 0f, Random.Range(-1.5f, 1.5f));
						SpawnCustomMessage spawnCustomMessage = new SpawnCustomMessage
						{
							position = self.createPickupInfo.position + val,
							pickupIndex = randomPickupForTier
						};
						((NetworkBehaviour)item).connectionToClient.Send((short)969, (MessageBase)(object)spawnCustomMessage);
						Log.Info($"Catchup drop for {item.userName}: tier={catchupTier.Value} deficit={deficit} chance={catchupChance:P} pickup={randomPickupForTier.value}");
					}
				}
			}
		}

		private void NetworkMessageHandlerAttribute_RegisterClientMessages(orig_RegisterClientMessages orig, NetworkClient client)
		{
			//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_0028: Expected O, but got Unknown
			orig.Invoke(client);
			object obj = <>O.<1>__HandlePickupMessage;
			if (obj == null)
			{
				NetworkMessageDelegate val = SpawnCustomController.HandlePickupMessage;
				<>O.<1>__HandlePickupMessage = val;
				obj = (object)val;
			}
			client.RegisterHandler((short)969, (NetworkMessageDelegate)obj);
		}

		private static float Util_GetExpAdjustedDropChancePercent(orig_GetExpAdjustedDropChancePercent orig, float nativeBaseDropChance, GameObject characterBodyObject)
		{
			float num = orig.Invoke(nativeBaseDropChance, characterBodyObject);
			float num2 = dropRateManager.ComputeDropChance(IsSwarmEnabled(), num, nativeBaseDropChance, dropChance);
			Log.Debug($"DropChance: original_base={nativeBaseDropChance} original_final={num}; plugin_base={dropChance}; plugin_final={num2} (Character={((Object)characterBodyObject).name})");
			DropRateTracker.RegisterDropOpportunity(num2);
			if (dropRateManager.NeedsBadLuckProtection(num2, Run.instance.GetRunStopwatch()))
			{
				return dropRateManager.GetBadLuckProtectedDropChance(num2);
			}
			return num2;
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSetDropRate(ConCommandArgs args)
		{
			dropChance = ((ConCommandArgs)(ref args)).GetArgFloat(0);
			useManualDropRate = true;
			Log.Info("Drop rate set to: " + ((ConCommandArgs)(ref args)).GetArgString(0) + "%");
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCGetDropRateReport(ConCommandArgs args)
		{
			if (IsModHooked)
			{
				DropRateTracker.LogReport();
			}
		}

		private static bool IsSacrificeEnabled()
		{
			if (RunArtifactManager.instance != null && ((Behaviour)RunArtifactManager.instance).isActiveAndEnabled)
			{
				return RunArtifactManager.instance.IsArtifactEnabled(Artifacts.sacrificeArtifactDef);
			}
			return false;
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSetHotkey(ConCommandArgs args)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (IsModHooked)
			{
				string argString = ((ConCommandArgs)(ref args)).GetArgString(0);
				if (Enum.TryParse<KeyCode>(argString, ignoreCase: true, out KeyCode result))
				{
					PullItemsHotKey.Value = result;
				}
				else
				{
					Log.Warning("Failed to set hotkey to " + argString);
				}
			}
		}

		private static bool IsCommandEnabled()
		{
			if (RunArtifactManager.instance != null && ((Behaviour)RunArtifactManager.instance).isActiveAndEnabled)
			{
				return RunArtifactManager.instance.IsArtifactEnabled(Artifacts.commandArtifactDef);
			}
			return false;
		}

		private static bool IsSwarmEnabled()
		{
			if (RunArtifactManager.instance != null && ((Behaviour)RunArtifactManager.instance).isActiveAndEnabled)
			{
				return RunArtifactManager.instance.IsArtifactEnabled(Artifacts.swarmsArtifactDef);
			}
			return false;
		}

		private int GetPlayerCount()
		{
			return PlayerCharacterMasterController.instances.Count((PlayerCharacterMasterController pc) => pc.isConnected);
		}
	}
	public class DropRateManager
	{
		private ConfigEntry<bool> EnableBadLuckProtection;

		private ConfigEntry<bool> EnableSwarmsScaling;

		private ConfigEntry<float> DropChanceMultiplier;

		private ConfigEntry<float> BaseDropChance;

		private ConfigEntry<float> MinimumDropChance;

		public DropRateManager(ConfigEntry<bool> enableBadLuckProtection, ConfigEntry<bool> enableSwarmsScaling, ConfigEntry<float> dropChanceMultiplier, ConfigEntry<float> baseDropChance, ConfigEntry<float> minimumDropChance)
		{
			EnableBadLuckProtection = enableBadLuckProtection;
			EnableSwarmsScaling = enableSwarmsScaling;
			DropChanceMultiplier = dropChanceMultiplier;
			BaseDropChance = baseDropChance;
			MinimumDropChance = minimumDropChance;
		}

		public float GetPlayerAwareBaseDropChance(int playerCount, float dropChance)
		{
			float num = 1f / (float)playerCount * DropChanceMultiplier.Value;
			float num2 = Math.Max(BaseDropChance.Value * num, MinimumDropChance.Value);
			if (!dropChance.Equals(num2))
			{
				dropChance = num2;
				Log.Debug($"Using dropRate of {dropChance}% (base={BaseDropChance.Value}, multiplier={DropChanceMultiplier.Value}, playerCount={playerCount}, minimumDropChance={MinimumDropChance.Value}");
			}
			return dropChance;
		}

		public float ComputeDropChance(bool isSwarmEnabled, float nativeDropChance, float nativeBaseDropChance, float dropChance)
		{
			float num = ((!(EnableSwarmsScaling.Value && isSwarmEnabled) || nativeDropChance == 0f) ? nativeDropChance : ((nativeDropChance - nativeBaseDropChance) * 0.6f + nativeBaseDropChance));
			float num2 = nativeBaseDropChance / 5f;
			float num3 = num / nativeBaseDropChance;
			return dropChance * num2 * num3;
		}

		public bool NeedsBadLuckProtection(float actualDropChance, float time)
		{
			if (EnableBadLuckProtection.Value && DropRateTracker.cumulativeDropChance >= 100f && actualDropChance > 0f)
			{
				bool num = DropRateTracker.expectedItems > (float)DropRateTracker.totalItemDrops;
				float num2 = (float)DropRateTracker.totalItemDrops / (time / 60f);
				if (!num)
				{
					return (double)num2 < 0.8;
				}
				return true;
			}
			return false;
		}

		public float GetBadLuckProtectedDropChance(float dropChance)
		{
			float num = DropRateTracker.cumulativeDropChance - 100f;
			float num2 = Math.Min(dropChance + num, 90f);
			Log.Debug($"Bad Luck Protection triggered! ({dropChance}% => {num2}%)");
			return num2;
		}
	}
	public static class DropRateTracker
	{
		private static Dictionary<float, long> DropRateReport = new Dictionary<float, long>();

		public static long totalItemDrops { get; private set; } = 0L;


		public static float cumulativeDropChance { get; private set; } = 0f;


		public static float expectedItems { get; private set; } = 0f;


		public static void ResetTracker()
		{
			DropRateReport = new Dictionary<float, long>();
			totalItemDrops = 0L;
			cumulativeDropChance = 0f;
			expectedItems = 0f;
		}

		public static void RegisterDropOpportunity(float dropChance)
		{
			cumulativeDropChance += dropChance;
			expectedItems += (float)Math.Round(dropChance / 100f, 2);
			if (DropRateReport.TryGetValue(dropChance, out var _))
			{
				DropRateReport[dropChance]++;
			}
			else
			{
				DropRateReport.Add(dropChance, 1L);
			}
		}

		public static void RegisterItemDrop(CreatePickupInfo createPickupInfo)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			PickupIndex pickupIndex = ((CreatePickupInfo)(ref createPickupInfo)).pickupIndex;
			if (((PickupIndex)(ref pickupIndex)).pickupDef != null)
			{
				pickupIndex = ((CreatePickupInfo)(ref createPickupInfo)).pickupIndex;
				PickupDef pickupDef = ((PickupIndex)(ref pickupIndex)).pickupDef;
				if (pickupDef.coinValue == 0 && pickupDef.nameToken != "PICKUP_LUNAR_COIN")
				{
					cumulativeDropChance = 0f;
					totalItemDrops++;
				}
			}
		}

		public static void LogReport()
		{
			if (Run.instance == null || !((Behaviour)Run.instance).isActiveAndEnabled)
			{
				return;
			}
			long num = DropRateReport.Values.Aggregate(0L, (long i, long l) => i + l);
			if (num != 0L)
			{
				string text = DropRateReport.Keys.OrderByDescending((float f) => f).Aggregate("Kills by Drop Rate", (string s, float f) => $"{s}\n  {f}%: {DropRateReport[f]} kills");
				float runStopwatch = Run.instance.GetRunStopwatch();
				float num2 = runStopwatch / 60f;
				float num3 = DropRateReport.Keys.Aggregate(0f, (float f, float f1) => f + (float)DropRateReport[f1] * f1) / (float)num;
				Log.Info(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat(string.Concat("------ DROP RATE RUN REPORT -----\n" + $"Stage: {Run.instance.stageClearCount + 1}\n", $"Run Duration: {runStopwatch}s\n"), $"Total kills: {num}\n"), $"Total items: {totalItemDrops}\n"), $"Theoretical Average Drop Rate: {num3}%\n"), $"Actual Average Drop Rate: {(float)totalItemDrops / (float)num * 100f}%\n"), $"Drops per Minute: {Math.Round((float)totalItemDrops / num2, 2)}\n"), text, "\n"), "------ END OF REPORT -----"));
			}
		}
	}
	internal static class Log
	{
		private static ManualLogSource _logSource;

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

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

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

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

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

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

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	public static class PlayerCatchupManager
	{
		private static readonly Dictionary<ItemTier, float> TierWeights = new Dictionary<ItemTier, float>
		{
			[(ItemTier)0] = 1f,
			[(ItemTier)1] = 3f,
			[(ItemTier)2] = 10f,
			[(ItemTier)4] = 15f
		};

		private static readonly HashSet<ItemTier> IgnoredTiers = new HashSet<ItemTier>
		{
			(ItemTier)3,
			(ItemTier)6,
			(ItemTier)7,
			(ItemTier)8,
			(ItemTier)9,
			(ItemTier)5
		};

		public static ItemTier? GetCatchupTier(NetworkUser user)
		{
			//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_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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: 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_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: 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_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			List<NetworkUser> players = GetPlayers();
			if (players.Count <= 1)
			{
				return null;
			}
			Dictionary<uint, Dictionary<ItemTier, int>> dictionary = new Dictionary<uint, Dictionary<ItemTier, int>>();
			NetworkInstanceId netId;
			foreach (NetworkUser item in players)
			{
				object obj;
				if (item == null)
				{
					obj = null;
				}
				else
				{
					CharacterMaster master = item.master;
					obj = ((master != null) ? master.inventory : null);
				}
				if ((Object)obj != (Object)null)
				{
					netId = ((NetworkBehaviour)item).netId;
					dictionary[((NetworkInstanceId)(ref netId)).Value] = CountItemsByTier(item);
				}
			}
			if (dictionary.Count <= 1)
			{
				return null;
			}
			netId = ((NetworkBehaviour)user).netId;
			if (!dictionary.TryGetValue(((NetworkInstanceId)(ref netId)).Value, out var value))
			{
				return null;
			}
			Dictionary<ItemTier, int> dictionary2 = new Dictionary<ItemTier, int>();
			foreach (ItemTier tier in TierWeights.Keys)
			{
				dictionary2[tier] = dictionary.Values.Select((Dictionary<ItemTier, int> c) => c.TryGetValue(tier, out var value3) ? value3 : 0).Max();
			}
			ItemTier? result = null;
			float num = 0f;
			foreach (ItemTier key in TierWeights.Keys)
			{
				int value2;
				int num2 = dictionary2[key] - (value.TryGetValue(key, out value2) ? value2 : 0);
				if (num2 > 0)
				{
					float num3 = (float)num2 * TierWeights[key];
					if (num3 > num)
					{
						num = num3;
						result = key;
					}
				}
			}
			return result;
		}

		public static int GetDeficit(NetworkUser user, ItemTier tier)
		{
			//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_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_00ac: 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)
			List<NetworkUser> players = GetPlayers();
			if (players.Count <= 1)
			{
				return 0;
			}
			Dictionary<uint, Dictionary<ItemTier, int>> dictionary = new Dictionary<uint, Dictionary<ItemTier, int>>();
			NetworkInstanceId netId;
			foreach (NetworkUser item in players)
			{
				object obj;
				if (item == null)
				{
					obj = null;
				}
				else
				{
					CharacterMaster master = item.master;
					obj = ((master != null) ? master.inventory : null);
				}
				if ((Object)obj != (Object)null)
				{
					netId = ((NetworkBehaviour)item).netId;
					dictionary[((NetworkInstanceId)(ref netId)).Value] = CountItemsByTier(item);
				}
			}
			netId = ((NetworkBehaviour)user).netId;
			if (!dictionary.TryGetValue(((NetworkInstanceId)(ref netId)).Value, out var value))
			{
				return 0;
			}
			int value2;
			int num = (value.TryGetValue(tier, out value2) ? value2 : 0);
			int value3;
			int num2 = dictionary.Values.Select((Dictionary<ItemTier, int> dict) => dict.TryGetValue(tier, out value3) ? value3 : 0).Max();
			return Math.Max(0, num2 - num);
		}

		public static float GetCatchupChance(int deficit, ItemTier tier)
		{
			if (deficit <= 0)
			{
				return 0f;
			}
			return Math.Min((float)deficit * 0.05f, 0.5f);
		}

		public static PickupIndex GetRandomPickupForTier(ItemTier tier)
		{
			//IL_000d: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected I4, but got Unknown
			//IL_0081: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Run.instance == (Object)null)
			{
				return PickupIndex.none;
			}
			try
			{
				List<PickupIndex> list = (int)tier switch
				{
					0 => Run.instance.availableTier1DropList, 
					1 => Run.instance.availableTier2DropList, 
					2 => Run.instance.availableTier3DropList, 
					4 => Run.instance.availableBossDropList, 
					_ => null, 
				};
				if (list != null && list.Count > 0)
				{
					return list[Random.Range(0, list.Count)];
				}
			}
			catch
			{
			}
			return PickupIndex.none;
		}

		private static List<NetworkUser> GetPlayers()
		{
			if (NetworkUser.readOnlyInstancesList != null && NetworkUser.readOnlyInstancesList.Count > 0)
			{
				return NetworkUser.readOnlyInstancesList.ToList();
			}
			return (from p in PlayerCharacterMasterController.instances
				where (Object)(object)((p != null) ? p.networkUser : null) != (Object)null
				select p.networkUser).ToList();
		}

		private static Dictionary<ItemTier, int> CountItemsByTier(NetworkUser user)
		{
			//IL_006d: 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_0052: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ItemTier, int> dictionary = new Dictionary<ItemTier, int>();
			object obj;
			if (user == null)
			{
				obj = null;
			}
			else
			{
				CharacterMaster master = user.master;
				obj = ((master != null) ? master.inventory : null);
			}
			Inventory val = (Inventory)obj;
			if ((Object)(object)val == (Object)null)
			{
				return dictionary;
			}
			foreach (ItemTier value in Enum.GetValues(typeof(ItemTier)))
			{
				if (!IgnoredTiers.Contains(value))
				{
					try
					{
						dictionary[value] = val.GetTotalItemCountOfTier(value);
					}
					catch
					{
						dictionary[value] = 0;
					}
				}
			}
			return dictionary;
		}
	}
	public class SpawnCustomController : NetworkBehaviour
	{
		[NetworkMessageHandler(msgType = 969, client = true)]
		public static void HandlePickupMessage(NetworkMessage netMsg)
		{
			//IL_002d: 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)
			SpawnCustomMessage spawnCustomMessage = new SpawnCustomMessage();
			netMsg.ReadMessage<SpawnCustomMessage>(spawnCustomMessage);
			Log.Info($"HandlePickupMessage {spawnCustomMessage.pickupIndex.value}");
			CreatePickupDroplet(spawnCustomMessage.pickupIndex, spawnCustomMessage.position);
		}

		public static void CreatePickupDroplet(PickupIndex pickupIndex, Vector3 position)
		{
			//IL_0002: 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_000f: 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_001c: 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_0021: 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_002d: 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_0046: 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)
			CreatePickupInfo val = default(CreatePickupInfo);
			val.rotation = Quaternion.identity;
			((CreatePickupInfo)(ref val)).pickupIndex = pickupIndex;
			CreatePickupInfo val2 = val;
			UniquePickup val3 = default(UniquePickup);
			((UniquePickup)(ref val3))..ctor(pickupIndex);
			GameObject obj = Object.Instantiate<GameObject>(CommandArtifactManager.commandCubePrefab, position, val2.rotation);
			PickupIndexNetworker component = obj.GetComponent<PickupIndexNetworker>();
			PickupPickerController component2 = obj.GetComponent<PickupPickerController>();
			component2.SetOptionsInternal(PickupPickerController.GetOptionsFromPickupState(val3));
			if (!NetworkServer.active)
			{
				((NetworkBehaviour)component2).SetDirtyBit(PickupPickerController.optionsDirtyBit);
			}
			component.NetworkpickupState = val3;
			if (Object.op_Implicit((Object)(object)component.pickupDisplay))
			{
				component.pickupDisplay.SetPickup(ref val3, false);
			}
		}

		public static void CreatePickupItem(PickupIndex pickupIndex, Vector3 position)
		{
			//IL_000a: 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_0017: 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_001f: 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_002c: 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_0031: 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_0046: 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_0048: 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_0078: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkServer.active)
			{
				CreatePickupInfo val = default(CreatePickupInfo);
				val.rotation = Quaternion.identity;
				val.position = position;
				((CreatePickupInfo)(ref val)).pickupIndex = pickupIndex;
				CreatePickupInfo val2 = val;
				UniquePickup val3 = default(UniquePickup);
				((UniquePickup)(ref val3))..ctor(pickupIndex);
				GameObject obj = Object.Instantiate<GameObject>(val2.prefabOverride ?? GenericPickupController.pickupPrefab, position, val2.rotation);
				GenericPickupController component = obj.GetComponent<GenericPickupController>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.Network_pickupState = val3;
				}
				PickupIndexNetworker component2 = obj.GetComponent<PickupIndexNetworker>();
				if (Object.op_Implicit((Object)(object)component2))
				{
					component2.NetworkpickupState = val3;
				}
				PickupPickerController component3 = obj.GetComponent<PickupPickerController>();
				if (Object.op_Implicit((Object)(object)component3) && val2.pickerOptions != null)
				{
					component3.SetOptionsServer(val2.pickerOptions);
				}
				NetworkServer.Spawn(obj);
			}
		}
	}
	public class SpawnCustomMessage : MessageBase, INetMessage, ISerializableObject
	{
		public Vector3 position;

		public PickupIndex pickupIndex;

		public override void Serialize(NetworkWriter writer)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(position);
			writer.Write(pickupIndex.value);
		}

		public override void Deserialize(NetworkReader reader)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			position = reader.ReadVector3();
			pickupIndex = new PickupIndex(reader.ReadInt32());
		}

		public void OnReceived()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			SpawnCustomController.CreatePickupItem(pickupIndex, position);
		}
	}
	public struct SpawnCustomMessage2 : INetMessage, ISerializableObject
	{
		public Vector3 position;

		public PickupIndex pickupIndex;

		public void Serialize(NetworkWriter writer)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(position);
			writer.Write(pickupIndex.value);
		}

		public void Deserialize(NetworkReader reader)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			position = reader.ReadVector3();
			pickupIndex = new PickupIndex(reader.ReadInt32());
		}

		public void OnReceived()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			SpawnCustomController.CreatePickupItem(pickupIndex, position);
		}

		public SpawnCustomMessage2(PickupIndex pickupIndex, Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			this.position = position;
			this.pickupIndex = pickupIndex;
		}
	}
}