using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using DiversityRemastered.Player;
using DunGen.Graph;
using GameNetcodeStuff;
using HarmonyLib;
using JLL.API;
using JLL.API.Compatability;
using JLL.API.Events;
using JLL.API.JSON.Objects;
using JLL.API.LevelProperties;
using JLL.Components;
using JLL.Components.Filters;
using JLL.NetcodePatcher;
using JLL.Patches;
using JLL.ScriptableObjects;
using LCCutscene;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalLevelLoader;
using LethalMoonUnlocks;
using LittleCompany.modifications;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Unity.AI.Navigation;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.Serialization;
using WeatherRegistry;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("JLL")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("JLL")]
[assembly: AssemblyTitle("JLL")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace JLL
{
	[BepInPlugin("JacobG5.JLL", "JLL", "1.9.5")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class JLL : BaseUnityPlugin
	{
		private const string modGUID = "JacobG5.JLL";

		private const string modName = "JLL";

		private const string modVersion = "1.9.5";

		private readonly Harmony harmony = new Harmony("JacobG5.JLL");

		public static JLL Instance;

		internal ManualLogSource mls;

		internal ManualLogSource wesley;

		private static Transform JLLPrefabContainer;

		public GameObject networkObject;

		public JNetworkPrefabSet JLLNetworkPrefabs;

		public static ConfigEntry<JLogLevel> loggingLevel;

		public static ConfigEntry<bool> purgeWesley;

		public static ConfigEntry<bool> disableCutscenes;

		private void Awake()
		{
			//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)
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			JLLPrefabContainer = new GameObject("JLLPrefabContainer")
			{
				hideFlags = (HideFlags)61
			}.transform;
			((Component)JLLPrefabContainer).gameObject.SetActive(false);
			mls = Logger.CreateLogSource("JacobG5.JLL");
			wesley = Logger.CreateLogSource("Wesley");
			NetcodePatch(mls, Assembly.GetExecutingAssembly().GetTypes());
			loggingLevel = ((BaseUnityPlugin)this).Config.Bind<JLogLevel>("Logging", "LoggingLevel", JLogLevel.User, "Changes the amount of logging JLL performs in it's scripts.");
			loggingLevel.SettingChanged += delegate
			{
				JLogHelper.UpdateLogLevel();
			};
			JLogHelper.UpdateLogLevel();
			JLLNetworkPrefabs = ScriptableObject.CreateInstance<JNetworkPrefabSet>();
			JLLNetworkPrefabs.SetName = "JLL";
			JLLNetworkPrefabs.AddPrefabs(new JNetworkPrefabSet.JIdentifiablePrefab
			{
				name = "JLL",
				prefab = (networkObject = CreateNetworkPrefab("JLL"))
			}, new JNetworkPrefabSet.JIdentifiablePrefab
			{
				name = "EmptyPrefab",
				prefab = (JNetworkPrefabSet.EmptyNetworkObject = CreateNetworkPrefab("EmptyPrefab"))
			});
			networkObject.AddComponent<JLLNetworkManager>();
			JNetworkPrefabSet.NetworkPrefabSets.Add(JLLNetworkPrefabs);
			purgeWesley = ((BaseUnityPlugin)this).Config.Bind<bool>("Logging", "PurgeWesley", false, "Destroys him.");
			if (JCompatabilityHelper.IsLoaded(JCompatabilityHelper.CachedMods.LCCutscene))
			{
				disableCutscenes = ((BaseUnityPlugin)this).Config.Bind<bool>("LCCutscene", "DisableJLLCutscenes", false, "A global shutoff for all cutscenes triggered by JLL using LCCutscene.");
			}
			if (JCompatabilityHelper.IsLoaded(JCompatabilityHelper.CachedMods.LethalConfig))
			{
				LethalConfigHelper.CreateJLLModConfig();
			}
			HarmonyPatch(harmony, mls, typeof(ItemChargerPatch), typeof(TimeOfDayPatch), typeof(HudManagerPatch), typeof(StartOfRoundPatch), typeof(RoundManagerPatch), typeof(LungPropPatch), typeof(VehicleControllerPatch), typeof(MenuManagerPatch), typeof(BreakerBoxPatch), typeof(ItemDropshipPatch), typeof(GameNetworkManagerPatch));
			JFileHelper.LoadFilesInPlugins();
		}

		public static GameObject CreateNetworkPrefab(string name)
		{
			//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_0015: Expected O, but got Unknown
			GameObject val = new GameObject("JLL")
			{
				hideFlags = (HideFlags)61
			};
			val.transform.SetParent(JLLPrefabContainer);
			byte[] value = MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(Assembly.GetCallingAssembly().GetName().Name + name));
			Traverse.Create((object)val.AddComponent<NetworkObject>()).Field("GlobalObjectIdHash").SetValue((object)BitConverter.ToUInt32(value, 0));
			return val;
		}

		public static void HarmonyPatch(Harmony harmony, ManualLogSource logSource, params Type[] patches)
		{
			foreach (Type type in patches)
			{
				try
				{
					harmony.PatchAll(type);
				}
				catch (Exception arg)
				{
					logSource.LogError((object)$"Caught Error while trying to patch {type.Name}\n{arg}");
				}
			}
		}

		public static void NetcodePatch(ManualLogSource logSource)
		{
			NetcodePatch(logSource, Assembly.GetCallingAssembly().GetTypes());
		}

		public static void NetcodePatch(ManualLogSource logSource, params Type[] types)
		{
			foreach (Type type in types)
			{
				try
				{
					MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
					MethodInfo[] array = methods;
					foreach (MethodInfo methodInfo in array)
					{
						object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
						if (customAttributes.Length != 0)
						{
							methodInfo.Invoke(null, null);
						}
					}
				}
				catch
				{
					logSource.LogInfo((object)"Skipping Netcode Class");
				}
			}
			logSource.LogInfo((object)"Netcode Successfully Patched!");
		}
	}
}
namespace JLL.ScriptableObjects
{
	[CreateAssetMenu(menuName = "JLL/JLevelProperties")]
	public class JLevelProperties : ScriptableObject
	{
		[Header("-=-EXPERIMENTAL-=-")]
		public JLevelPropertyEntry Properties = new JLevelPropertyEntry();
	}
	public abstract class JLLAddon : ScriptableObject
	{
		public abstract void Init(JLLMod parent);
	}
	[CreateAssetMenu(menuName = "JLL/JLLMod")]
	public class JLLMod : ScriptableObject
	{
		[Serializable]
		public class ConfigValue<T>
		{
			public string configName = "Example";

			public string configCategory = "Main";

			public string configDescription = "";

			public T defaultValue;
		}

		private static readonly List<JLLMod> m_ModList = new List<JLLMod>();

		public string modAuthor = "";

		public string modName = "";

		[Header("Network Prefabs")]
		public JNetworkPrefabSet[] prefabSets = new JNetworkPrefabSet[0];

		[Header("Config Values")]
		public List<ConfigValue<bool>> Booleans = new List<ConfigValue<bool>>();

		public List<ConfigValue<string>> Strings = new List<ConfigValue<string>>();

		public List<ConfigValue<int>> Integers = new List<ConfigValue<int>>();

		public List<ConfigValue<float>> Floats = new List<ConfigValue<float>>();

		[Header("JLL Addons")]
		public JLLAddon[] jllAddons = new JLLAddon[0];

		public static JLLMod? GetMod(string name, string author)
		{
			return GetMod(author + "." + name);
		}

		public static JLLMod? GetMod(string guid)
		{
			for (int i = 0; i < m_ModList.Count; i++)
			{
				if (m_ModList[i].GUID() == guid)
				{
					return m_ModList[i];
				}
			}
			return null;
		}

		public static JLLMod[] GetModsFromAuthor(string author)
		{
			List<JLLMod> list = new List<JLLMod>();
			for (int i = 0; i < m_ModList.Count; i++)
			{
				if (m_ModList[i].modAuthor == author)
				{
					list.Add(m_ModList[i]);
				}
			}
			return list.ToArray();
		}

		public string GUID()
		{
			return modAuthor + "." + modName;
		}

		public bool Invalid()
		{
			return Utility.IsNullOrWhiteSpace(modAuthor) || Utility.IsNullOrWhiteSpace(modName);
		}

		public bool HasConfigs()
		{
			return Booleans.Count + Strings.Count + Integers.Count + Floats.Count > 0;
		}

		internal void Init()
		{
			if (!m_ModList.Contains(this))
			{
				m_ModList.Add(this);
			}
			for (int i = 0; i < prefabSets.Length; i++)
			{
				if (!JNetworkPrefabSet.NetworkPrefabSets.Contains(prefabSets[i]))
				{
					JNetworkPrefabSet.NetworkPrefabSets.Add(prefabSets[i]);
				}
			}
			for (int j = 0; j < jllAddons.Length; j++)
			{
				try
				{
					jllAddons[j].Init(this);
				}
				catch (Exception arg)
				{
					JLogHelper.LogError($"JLL Addon failed to initialize from {GUID()}: {arg}");
				}
			}
		}

		public JNetworkPrefabSet? GetNetworkPrefabSet(string name)
		{
			for (int i = 0; i < prefabSets.Length; i++)
			{
				if (prefabSets[i].SetName == name)
				{
					return prefabSets[i];
				}
			}
			return null;
		}
	}
	[CreateAssetMenu(menuName = "JLL/Collections/JLLModCollection", order = 20)]
	public class JLLModCollection : ScriptableObject
	{
		public JLLMod[] Mods = new JLLMod[0];
	}
	[CreateAssetMenu(menuName = "JLL/JNetworkPrefabSet")]
	public class JNetworkPrefabSet : ScriptableObject
	{
		[Serializable]
		public class JIdentifiablePrefab : IWeightedItem
		{
			public string name;

			public GameObject prefab;

			[Range(0f, 100f)]
			public int Weight = 20;

			public int GetWeight()
			{
				return Weight;
			}
		}

		public static readonly List<JNetworkPrefabSet> NetworkPrefabSets = new List<JNetworkPrefabSet>();

		public string SetName;

		public JIdentifiablePrefab[] prefabList = new JIdentifiablePrefab[1]
		{
			new JIdentifiablePrefab()
		};

		public static GameObject EmptyNetworkObject { get; internal set; }

		public void AddPrefabs(params JIdentifiablePrefab[] prefabsToAdd)
		{
			List<JIdentifiablePrefab> list = prefabList.ToList();
			list.AddRange(prefabsToAdd);
			prefabList = list.ToArray();
		}

		public void AddPrefab(string name, GameObject prefab, int weight = 20)
		{
			AddPrefabs(new JIdentifiablePrefab
			{
				name = name,
				prefab = prefab,
				Weight = weight
			});
		}

		internal static void RegisterPrefabs()
		{
			NetworkManager component = ((Component)GameNetworkManager.Instance).GetComponent<NetworkManager>();
			List<GameObject> list = new List<GameObject>();
			foreach (NetworkPrefab prefab in component.NetworkConfig.Prefabs.Prefabs)
			{
				list.Add(prefab.Prefab);
			}
			int num = 0;
			foreach (JNetworkPrefabSet networkPrefabSet in NetworkPrefabSets)
			{
				for (int i = 0; i < networkPrefabSet.prefabList.Length; i++)
				{
					if (!((Object)(object)networkPrefabSet.prefabList[i].prefab == (Object)null) && !list.Contains(networkPrefabSet.prefabList[i].prefab))
					{
						try
						{
							component.AddNetworkPrefab(networkPrefabSet.prefabList[i].prefab);
							num++;
							JLogHelper.LogInfo("Registered Network Object: " + networkPrefabSet.prefabList[i].name + " (" + ((Object)networkPrefabSet.prefabList[i].prefab).name + ")", JLogLevel.Wesley);
						}
						catch (Exception arg)
						{
							JLogHelper.LogError($"JLL Addon failed to register network object: {arg}");
						}
					}
				}
			}
			JLogHelper.LogInfo($"Registered {num} Network Objects");
		}

		public GameObject GetPrefab(string name)
		{
			for (int i = 0; i < prefabList.Length; i++)
			{
				if (prefabList[i].name == name)
				{
					return prefabList[i].prefab;
				}
			}
			return EmptyNetworkObject;
		}

		public bool GetPrefab(string name, out GameObject prefab)
		{
			for (int i = 0; i < prefabList.Length; i++)
			{
				if (prefabList[i].name == name)
				{
					prefab = prefabList[i].prefab;
					return true;
				}
			}
			prefab = EmptyNetworkObject;
			return false;
		}

		public GameObject GetRandomPrefab()
		{
			return prefabList.GetWeightedRandom().prefab;
		}
	}
}
namespace JLL.Patches
{
	[HarmonyPatch(typeof(BreakerBox))]
	internal class BreakerBoxPatch
	{
		[HarmonyPatch("SwitchBreaker")]
		[HarmonyPostfix]
		public static void patchSwitchBreaker(bool on)
		{
			for (int i = 0; i < JLevelEventTriggers.EventTriggers.Count; i++)
			{
				JLevelEventTriggers.EventTriggers[i].ToggleBreakerBox(on);
			}
		}

		[HarmonyPatch("SetSwitchesOff")]
		[HarmonyPostfix]
		public static void patchSetSwitchesOff()
		{
			for (int i = 0; i < JLevelEventTriggers.EventTriggers.Count; i++)
			{
				JLevelEventTriggers.EventTriggers[i].ToggleBreakerBox(active: false);
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager))]
	public class GameNetworkManagerPatch
	{
		private static bool registeredPrefabs;

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void patchStart(GameNetworkManager __instance)
		{
			if (!registeredPrefabs)
			{
				registeredPrefabs = true;
				((MonoBehaviour)__instance).StartCoroutine(RegisterNetworkPrefabs());
			}
		}

		private static IEnumerator RegisterNetworkPrefabs()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => JFileHelper.HaveJLLBundlesLoaded));
			JNetworkPrefabSet.RegisterPrefabs();
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	public class HudManagerPatch
	{
		public static JWaterFilter? customFilter;

		[HarmonyPatch("UnderwaterScreenFilters")]
		[HarmonyPrefix]
		public static bool patchUnderwaterScreenFilters(HUDManager __instance)
		{
			//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_0062: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB localPlayer = __instance.localPlayer;
			if ((Object)(object)__instance.localPlayer != (Object)null)
			{
				bool flag = false;
				PlayerControllerB spectatedPlayerScript = localPlayer.spectatedPlayerScript;
				if (localPlayer.isPlayerDead && (Object)(object)spectatedPlayerScript != (Object)null && (Object)(object)spectatedPlayerScript.underwaterCollider != (Object)null)
				{
					Bounds bounds = spectatedPlayerScript.underwaterCollider.bounds;
					if (((Bounds)(ref bounds)).Contains(((Component)StartOfRound.Instance.spectateCamera).transform.position))
					{
						flag = true;
						((Component)spectatedPlayerScript.underwaterCollider).TryGetComponent<JWaterFilter>(ref customFilter);
					}
				}
				if ((Object)(object)customFilter == (Object)null && !localPlayer.isPlayerDead && (Object)(object)localPlayer.underwaterCollider != (Object)null)
				{
					((Component)localPlayer.underwaterCollider).TryGetComponent<JWaterFilter>(ref customFilter);
				}
				if ((Object)(object)customFilter != (Object)null)
				{
					if (__instance.setUnderwaterFilter || flag)
					{
						customFilter.UnderwaterFilters(__instance, flag);
						__instance.breathingUnderwaterAudio.volume = Mathf.Lerp(__instance.breathingUnderwaterAudio.volume, 1f, 10f * Time.deltaTime);
						if ((Object)(object)customFilter.customUnderwaterSounds != (Object)null)
						{
							customFilter.customUnderwaterSounds.volume = __instance.breathingUnderwaterAudio.volume;
						}
					}
					else
					{
						if (__instance.audioListenerLowPass.cutoffFrequency >= 19000f)
						{
							((Behaviour)__instance.audioListenerLowPass).enabled = false;
						}
						else
						{
							__instance.audioListenerLowPass.cutoffFrequency = Mathf.Lerp(__instance.audioListenerLowPass.cutoffFrequency, 20000f, 10f * Time.deltaTime);
						}
						if (customFilter.underwaterFilter.weight < 0.05f)
						{
							customFilter.underwaterFilter.weight = 0f;
							__instance.breathingUnderwaterAudio.Stop();
							if ((Object)(object)customFilter.customUnderwaterSounds != (Object)null)
							{
								customFilter.customUnderwaterSounds.Stop();
							}
							customFilter = null;
						}
						else
						{
							__instance.breathingUnderwaterAudio.volume = Mathf.Lerp(__instance.breathingUnderwaterAudio.volume, 0f, 10f * Time.deltaTime);
							if ((Object)(object)customFilter.customUnderwaterSounds != (Object)null)
							{
								customFilter.customUnderwaterSounds.volume = __instance.breathingUnderwaterAudio.volume;
							}
							customFilter.underwaterFilter.weight = Mathf.Lerp(customFilter.underwaterFilter.weight, 0f, 10f * Time.deltaTime);
						}
					}
					return false;
				}
			}
			return true;
		}

		[HarmonyPatch("DisplayTip")]
		[HarmonyPrefix]
		public static void patchDisplayTip(HUDManager __instance)
		{
			JHudHelper.isTipActive = true;
			((MonoBehaviour)__instance).StartCoroutine(TipQueueCheck());
		}

		private static IEnumerator TipQueueCheck()
		{
			yield return (object)new WaitForSeconds(5f);
			JHudHelper.isTipActive = false;
			JHudHelper.DisplayNextTip();
		}
	}
	[HarmonyPatch(typeof(ItemCharger))]
	internal class ItemChargerPatch
	{
		[HarmonyPatch("chargeItemDelayed")]
		[HarmonyPrefix]
		public static void patchChargeItemDelayed(ItemCharger __instance)
		{
			ChargeLimiter chargeLimiter = default(ChargeLimiter);
			if (((Component)__instance).TryGetComponent<ChargeLimiter>(ref chargeLimiter))
			{
				JLogHelper.LogInfo("Found Limiter");
				chargeLimiter.Charge();
			}
		}
	}
	[HarmonyPatch(typeof(ItemDropship))]
	internal class ItemDropshipPatch
	{
		[HarmonyPatch("OpenShipDoorsOnServer")]
		[HarmonyPostfix]
		public static void patchOpenShipDoorsOnServer(ItemDropship __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			JItemDropshipModifier jItemDropshipModifier = default(JItemDropshipModifier);
			if (!((Component)__instance).TryGetComponent<JItemDropshipModifier>(ref jItemDropshipModifier))
			{
				return;
			}
			GrabbableObject val = default(GrabbableObject);
			for (int i = 0; i < __instance.itemSpawnPositions.Length; i++)
			{
				Collider[] array = Physics.OverlapSphere(__instance.itemSpawnPositions[i].position, 0.5f, 64);
				for (int j = 0; j < array.Length; j++)
				{
					if (((Component)array[j]).gameObject.TryGetComponent<GrabbableObject>(ref val))
					{
						JLogHelper.LogInfo("Found dropship item! " + val.itemProperties.itemName, JLogLevel.Wesley);
						jItemDropshipModifier.ModifyDroppedItems(val);
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(LungProp))]
	internal class LungPropPatch
	{
		private static EnemyType? VanillaRadMech;

		[HarmonyPatch("EquipItem")]
		[HarmonyPrefix]
		public static void patchEquipItem(LungProp __instance)
		{
			if (__instance.isLungDocked)
			{
				if ((Object)(object)VanillaRadMech == (Object)null)
				{
					VanillaRadMech = JLevelPropertyRegistry.GetRegisteredEnemy("RadMech");
				}
				__instance.radMechEnemyType = VanillaRadMech;
				JLevelPropertyRegistry.ApparatusPulled = true;
				for (int i = 0; i < JLevelEventTriggers.EventTriggers.Count; i++)
				{
					JLevelEventTriggers.EventTriggers[i].InvokeApparatus();
				}
			}
		}
	}
	[HarmonyPatch(typeof(MenuManager))]
	internal class MenuManagerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		public static void patchStart()
		{
			JLevelPropertyRegistry.RemoveLevelOverrides();
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	internal class RoundManagerPatch
	{
		[HarmonyPatch("FinishGeneratingLevel")]
		[HarmonyPrefix]
		public static void spawnFinishGeneratingLevel()
		{
			JMaterialReplacer[] array = Object.FindObjectsOfType<JMaterialReplacer>();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].triggerPostDunGen)
				{
					array[i].SearchAndReplace();
				}
			}
		}

		[HarmonyPatch("FinishGeneratingNewLevelClientRpc")]
		[HarmonyPostfix]
		public static void patchPostLevelGeneration()
		{
			if (JLevelPropertyRegistry.IsLevelGenerated)
			{
				return;
			}
			JLevelPropertyRegistry.ApplyLevelOverrides();
			IDungeonLoadListener[] array = Object.FindObjectsOfType<MonoBehaviour>().OfType<IDungeonLoadListener>().ToArray();
			if (array.Length != 0)
			{
				for (int i = 0; i < array.Length; i++)
				{
					array[i].PostDungeonGeneration();
				}
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void StartOfRound_Start(StartOfRound __instance)
		{
			if (((NetworkBehaviour)__instance).IsHost || ((NetworkBehaviour)__instance).IsServer)
			{
				GameObject val = Object.Instantiate<GameObject>(JLL.Instance.networkObject);
				val.GetComponent<NetworkObject>().Spawn(false);
				JLogHelper.LogInfo("JLL Network Manager Initialized.", JLogLevel.User);
			}
			((MonoBehaviour)__instance).StartCoroutine(StoreDefaults());
		}

		private static IEnumerator StoreDefaults()
		{
			yield return (object)new WaitForSeconds(0.5f);
			List<EnemyType> enemyTypes = new List<EnemyType>();
			SelectableLevel allEnemiesLevel = Object.FindObjectOfType<QuickMenuManager>().testAllEnemiesLevel;
			FindEnemyTypes(allEnemiesLevel.Enemies, ref enemyTypes);
			FindEnemyTypes(allEnemiesLevel.OutsideEnemies, ref enemyTypes);
			FindEnemyTypes(allEnemiesLevel.DaytimeEnemies, ref enemyTypes);
			JLevelPropertyRegistry.AllSortedEnemies.Clear();
			JLevelPropertyRegistry.AllSortedEnemies.AddRange(enemyTypes);
		}

		private static void FindEnemyTypes(List<SpawnableEnemyWithRarity> spawnableEnemies, ref List<EnemyType> enemyTypes)
		{
			for (int i = 0; i < spawnableEnemies.Count; i++)
			{
				if ((Object)(object)spawnableEnemies[i].enemyType != (Object)null && !enemyTypes.Contains(spawnableEnemies[i].enemyType))
				{
					enemyTypes.Add(spawnableEnemies[i].enemyType);
				}
			}
		}

		[HarmonyPatch("EndOfGame")]
		[HarmonyPrefix]
		public static void patchEndOfGame()
		{
			JWeatherOverride.Instance = null;
			if ((Object)(object)HudManagerPatch.customFilter != (Object)null)
			{
				HudManagerPatch.customFilter.underwaterFilter.weight = 0f;
				HudManagerPatch.customFilter = null;
			}
			JLevelPropertyRegistry.RemoveLevelOverrides();
		}

		[HarmonyPatch("OnShipLandedMiscEvents")]
		[HarmonyPrefix]
		public static void patchOnShipLandedMiscEvents()
		{
			for (int i = 0; i < JLevelEventTriggers.EventTriggers.Count; i++)
			{
				JLevelEventTriggers.EventTriggers[i].ShipLanded.Invoke();
			}
		}

		[HarmonyPatch("ShipLeave")]
		[HarmonyPrefix]
		public static void patchShipLeave()
		{
			for (int i = 0; i < JLevelEventTriggers.EventTriggers.Count; i++)
			{
				JLevelEventTriggers.EventTriggers[i].ShipLeaving.Invoke();
			}
		}
	}
	[HarmonyPatch(typeof(TimeOfDay))]
	internal class TimeOfDayPatch
	{
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPatch(typeof(TimeOfDay), "DisableWeatherEffect")]
		public static void DisableWeatherEffect(object instance, WeatherEffect effect)
		{
			throw new NotImplementedException("It's a stub");
		}

		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPatch(typeof(TimeOfDay), "fadeOutEffect")]
		public static IEnumerator fadeOutEffect(object instance, WeatherEffect effect, Vector3 moveFromPosition)
		{
			throw new NotImplementedException("It's a stub");
		}

		[HarmonyPatch("DisableWeatherEffect")]
		[HarmonyPrefix]
		public static void DisableWeatherEffect(WeatherEffect effect)
		{
			JWeatherOverride instance = JWeatherOverride.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				WeatherEffect overrideEffect = instance.getOverrideEffect(effect.name);
				if (overrideEffect != null && (Object)(object)overrideEffect.effectObject != (Object)null)
				{
					overrideEffect.effectObject.SetActive(false);
				}
			}
		}

		[HarmonyPatch("DisableAllWeather")]
		[HarmonyPrefix]
		public static void DisableAllWeather(bool deactivateObjects)
		{
			JWeatherOverride instance = JWeatherOverride.Instance;
			if (!((Object)(object)instance != (Object)null))
			{
				return;
			}
			for (int i = 0; i < instance.overrideEffects.Length; i++)
			{
				WeatherEffect val = instance.overrideEffects[i];
				val.effectEnabled = false;
				if (deactivateObjects && (Object)(object)val.effectObject != (Object)null)
				{
					val.effectObject.SetActive(false);
				}
			}
		}
	}
	[HarmonyPatch(typeof(VehicleController))]
	public class VehicleControllerPatch
	{
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPatch(typeof(VehicleController), "DealPermanentDamage")]
		public static void DealPermanentDamage(object instance, int damageAmount, Vector3 damagePosition = default(Vector3))
		{
			throw new NotImplementedException("It's a stub");
		}
	}
}
namespace JLL.Components
{
	public class AttatchToObject : MonoBehaviour
	{
		public Transform parent;

		public bool attatchPos = true;

		public bool attatchRot = true;

		private void Update()
		{
			UpdatePosition();
		}

		private void LateUpdate()
		{
			UpdatePosition();
		}

		public void UpdatePosition()
		{
			//IL_003d: 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)
			if (!((Object)(object)parent == (Object)null) && Object.op_Implicit((Object)(object)parent))
			{
				if (attatchPos)
				{
					((Component)this).transform.position = parent.position;
				}
				if (attatchRot)
				{
					((Component)this).transform.rotation = parent.rotation;
				}
			}
		}
	}
	public class ChargeLimiter : MonoBehaviour
	{
		public int charges = 1;

		public InteractTrigger trigger;

		public GameObject disableObject;

		public void Charge()
		{
			charges--;
			if (charges <= 0)
			{
				SetHasCharge(value: false);
			}
		}

		public void SetHasCharge(bool value)
		{
			BoxCollider val = default(BoxCollider);
			if ((Object)(object)trigger != (Object)null && ((Component)trigger).TryGetComponent<BoxCollider>(ref val))
			{
				((Collider)val).enabled = value;
			}
			if ((Object)(object)disableObject != (Object)null)
			{
				disableObject.SetActive(value);
			}
		}

		public void AddCharges(int amount)
		{
			charges += amount;
		}
	}
	public class ClientSeperator : MonoBehaviour
	{
		[Tooltip("Event run for the given client.")]
		public InteractEvent eventsForClient = new InteractEvent();

		[Tooltip("Event run for every client except the given one.")]
		public UnityEvent eventsForEveryoneElse = new UnityEvent();

		public void SeperateClientEvents(PlayerControllerB player)
		{
			if (player.IsLocalPlayer())
			{
				((UnityEvent<PlayerControllerB>)(object)eventsForClient).Invoke(player);
			}
			else
			{
				eventsForEveryoneElse.Invoke();
			}
		}
	}
	public class DamageTrigger : MonoBehaviour
	{
		[Serializable]
		public class DamageTarget<T>
		{
			public bool enabled = false;

			public int damage = 1;

			public bool applyDamageMultiplier = true;

			public bool playCustomSounds = true;

			public UnityEvent<T> hitEvent = new UnityEvent<T>();

			public int GetTotalDamage(float multiplier = 1f)
			{
				if (applyDamageMultiplier)
				{
					return Mathf.RoundToInt((float)damage * multiplier);
				}
				return damage;
			}
		}

		[SerializeField]
		public CauseOfDeath damageSource = (CauseOfDeath)0;

		public Vector3 hitDir = Vector3.zero;

		public RotationType hitRotation = RotationType.ObjectRotation;

		[Tooltip("Check RoundManager in the Ship Scene for corpse IDs\nA negative copseType will result in no corpse spawning.")]
		public int corpseType = 0;

		public Mesh OverrideCorpseMesh;

		public bool attachCorpseToPoint = false;

		public Transform corpseAttachPoint;

		public PlayerBone connectedBone = PlayerBone.Base;

		public bool matchPointExactly = false;

		[Tooltip("Negative number will stay stuck to a point indefinately.")]
		public float corpseStickTime = 2f;

		[Header("NetworkHelper")]
		[Tooltip("This is only required to trigger some network related events.")]
		public DamageTriggerNetworking? DamageTriggerNetworking;

		[Header("Conditions")]
		[Tooltip("Damage when something enters a trigger collider")]
		public bool damageOnEnter = true;

		[Tooltip("Damage when something exits a trigger collider")]
		public bool damageOnExit = false;

		[Tooltip("Damage when something collides with a non trigger collider")]
		public bool damageOnCollision = true;

		[Header("Continuous Damage")]
		[Tooltip("Continuously damages anything inside of it's trigger collider")]
		public bool continuousDamage = true;

		[Tooltip("Continuously calculates a raycast and attempts to damage the whatever the ray hits")]
		public bool continuousRaycastDamage = false;

		public float hitInterval = 0.5f;

		private float timer = 0f;

		[Header("Raycast")]
		public float raycastLength = 6f;

		public Transform[] raycastDirections = (Transform[])(object)new Transform[0];

		public LayerMask raycastMask = LayerMask.op_Implicit(1202194760);

		[Header("Targets")]
		public float damageMultiplier = 1f;

		[Tooltip("Players have 100 HP")]
		public DamageTarget<PlayerControllerB> playerTargets = new DamageTarget<PlayerControllerB>();

		[Tooltip("Any instance of EnemyAICollisionDetect converted to EnemyAI")]
		public DamageTarget<EnemyAI> enemyTargets = new DamageTarget<EnemyAI>();

		[Tooltip("The Company Cruiser has 30 HP")]
		public DamageTarget<VehicleController> vehicleTargets = new DamageTarget<VehicleController>();

		[Tooltip("Anything that is damageable by shovels but not one of the things above")]
		public DamageTarget<IHittable> objectTargets = new DamageTarget<IHittable>();

		[Header("SFX")]
		public bool playNormalDamageSFX = true;

		public AudioClip[] clips = (AudioClip[])(object)new AudioClip[0];

		public AudioSource[] sources = (AudioSource[])(object)new AudioSource[0];

		private readonly Dictionary<GameObject, int> collidersInside = new Dictionary<GameObject, int>();

		private readonly List<GameObject> markedForRemoval = new List<GameObject>();

		private readonly List<GameObject> foundInside = new List<GameObject>();

		private void Start()
		{
			if ((Object)(object)DamageTriggerNetworking != (Object)null)
			{
				DamageTriggerNetworking.DamageTrigger = this;
			}
		}

		public void OnTriggerStay(Collider collider)
		{
			foundInside.Add(((Component)collider).gameObject);
			if (collidersInside.ContainsKey(((Component)collider).gameObject))
			{
				return;
			}
			int num = IdentifyCollider(((Component)collider).gameObject);
			if (!IsTargetDead(((Component)collider).gameObject, num))
			{
				collidersInside.Add(((Component)collider).gameObject, num);
				if (damageOnEnter)
				{
					DamageType(((Component)collider).gameObject, num);
				}
			}
		}

		public void FixedUpdate()
		{
			foreach (KeyValuePair<GameObject, int> item in collidersInside)
			{
				if (!foundInside.Contains(item.Key))
				{
					if (damageOnExit)
					{
						DamageType(item.Key, item.Value);
					}
					markedForRemoval.Add(item.Key);
				}
			}
			foundInside.Clear();
		}

		public void OnDisable()
		{
			collidersInside.Clear();
		}

		public void OnCollisionEnter(Collision collision)
		{
			if (damageOnCollision)
			{
				int num = IdentifyCollider(collision.gameObject);
				if (num != -1)
				{
					DamageType(collision.gameObject, num);
				}
			}
		}

		private void OnDrawGizmos()
		{
			//IL_0018: 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_0037: 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)
			if (raycastLength > 0f)
			{
				for (int i = 0; i < raycastDirections.Length; i++)
				{
					Gizmos.color = Color.red;
					Gizmos.DrawRay(((Component)this).transform.position, GetRayDirection(raycastDirections[i]) * raycastLength);
				}
			}
		}

		public void Update()
		{
			for (int i = 0; i < markedForRemoval.Count; i++)
			{
				collidersInside.Remove(markedForRemoval[i]);
			}
			markedForRemoval.Clear();
			if (!continuousDamage && !continuousRaycastDamage)
			{
				return;
			}
			timer -= Time.deltaTime;
			if (timer <= 0f)
			{
				timer = hitInterval;
				if (continuousDamage)
				{
					DamageAllInside();
				}
				if (continuousRaycastDamage)
				{
					DamageRaycast();
				}
			}
		}

		public void DamageAllInside()
		{
			foreach (KeyValuePair<GameObject, int> item in collidersInside)
			{
				DamageType(item.Key, item.Value);
			}
		}

		private void DamageType(GameObject target, int type)
		{
			switch (type)
			{
			case 0:
				if (playerTargets.enabled)
				{
					DamagePlayer(target.GetComponent<PlayerControllerB>());
				}
				break;
			case 1:
				if (enemyTargets.enabled)
				{
					DamageEnemy(target.GetComponent<EnemyAICollisionDetect>().mainScript);
				}
				break;
			case 2:
				if (vehicleTargets.enabled)
				{
					DamageVehicle(target.GetComponent<VehicleController>());
				}
				break;
			case 3:
				if (objectTargets.enabled)
				{
					DamageObject(target.GetComponent<IHittable>());
				}
				break;
			}
		}

		public static bool IsTargetDead(GameObject target, int type)
		{
			if (1 == 0)
			{
			}
			bool result = type switch
			{
				0 => target.GetComponent<PlayerControllerB>().isPlayerDead, 
				1 => target.GetComponent<EnemyAICollisionDetect>().mainScript.isEnemyDead, 
				2 => target.GetComponent<VehicleController>().carDestroyed, 
				_ => false, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public void DamageRaycast()
		{
			//IL_0021: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			if (!(raycastLength > 0f))
			{
				return;
			}
			RaycastHit val = default(RaycastHit);
			for (int i = 0; i < raycastDirections.Length; i++)
			{
				if (Physics.Raycast(((Component)this).transform.position, GetRayDirection(raycastDirections[i]), ref val, raycastLength, LayerMask.op_Implicit(raycastMask)))
				{
					int num = IdentifyCollider(((Component)((RaycastHit)(ref val)).collider).gameObject);
					if (num != -1)
					{
						DamageType(((Component)((RaycastHit)(ref val)).collider).gameObject, num);
					}
				}
			}
		}

		private Vector3 GetRayDirection(Transform target)
		{
			//IL_0002: 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_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_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_0022: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = target.position - ((Component)this).transform.position;
			return ((Vector3)(ref val)).normalized;
		}

		public static int IdentifyCollider(GameObject target)
		{
			if (target.CompareTag("Player"))
			{
				PlayerControllerB val = default(PlayerControllerB);
				if (target.TryGetComponent<PlayerControllerB>(ref val))
				{
					return 0;
				}
			}
			else if (target.CompareTag("Enemy"))
			{
				EnemyAICollisionDetect val2 = default(EnemyAICollisionDetect);
				if (target.TryGetComponent<EnemyAICollisionDetect>(ref val2))
				{
					return 1;
				}
			}
			else
			{
				VehicleController val3 = default(VehicleController);
				if (target.TryGetComponent<VehicleController>(ref val3))
				{
					return 2;
				}
				IHittable val4 = default(IHittable);
				if (target.TryGetComponent<IHittable>(ref val4))
				{
					return 3;
				}
			}
			return -1;
		}

		private Vector3 CalcHitDir(Transform target)
		{
			//IL_001d: 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_002c: 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_0037: 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_0073: 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_004e: 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_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_0077: 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)
			RotationType rotationType = hitRotation;
			if (1 == 0)
			{
			}
			Vector3 result = (Vector3)(rotationType switch
			{
				RotationType.ObjectRotation => Quaternion.AngleAxis(((Component)this).transform.rotation.y, Vector3.up) * hitDir, 
				RotationType.RandomRotation => Quaternion.AngleAxis(Random.Range(0f, 360f), Vector3.up) * hitDir, 
				_ => hitDir, 
			});
			if (1 == 0)
			{
			}
			return result;
		}

		public void SetDamageMultiplier(float multiplier)
		{
			damageMultiplier = multiplier;
		}

		public void DamagePlayer(PlayerControllerB player)
		{
			//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_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_006f: Unknown result type (might be due to invalid IL or missing references)
			if (player.isPlayerDead)
			{
				markedForRemoval.Add(((Component)player).gameObject);
				return;
			}
			int totalDamage = playerTargets.GetTotalDamage(damageMultiplier);
			CauseOfDeath val = damageSource;
			Vector3 val2 = CalcHitDir(((Component)player).transform);
			player.DamagePlayer(totalDamage, playNormalDamageSFX, true, val, Mathf.Clamp(corpseType, 0, StartOfRound.Instance.playerRagdolls.Count - 1), false, val2);
			playerTargets.hitEvent.Invoke(player);
			if (player.isPlayerDead)
			{
				if ((Object)(object)DamageTriggerNetworking != (Object)null)
				{
					DamageTriggerNetworking.DamageTriggerKilledPlayerServerRpc(player.Index());
				}
				else if (corpseType < 0)
				{
					JLLNetworkManager.Instance.DestroyPlayerCorpse(player);
				}
			}
			if (playerTargets.playCustomSounds)
			{
				PlayCustomAudio();
			}
		}

		public void SetPlayerDamage(int damage)
		{
			playerTargets.damage = damage;
		}

		public void DamageEnemy(EnemyAI enemy)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (enemy.isEnemyDead)
			{
				markedForRemoval.Add(((Component)enemy).gameObject);
				return;
			}
			enemy.HitEnemyOnLocalClient(enemyTargets.GetTotalDamage(damageMultiplier), CalcHitDir(((Component)enemy).transform), (PlayerControllerB)null, playNormalDamageSFX, -1);
			enemyTargets.hitEvent.Invoke(enemy);
			if ((((NetworkBehaviour)RoundManager.Instance).IsHost || ((NetworkBehaviour)RoundManager.Instance).IsServer) && enemy.isEnemyDead && (Object)(object)DamageTriggerNetworking != (Object)null)
			{
				DamageTriggerNetworking.DamageTriggerKilledServerRpc(1);
			}
			if (enemyTargets.playCustomSounds)
			{
				PlayCustomAudio();
			}
		}

		public void SetEnemyDamage(int damage)
		{
			enemyTargets.damage = damage;
		}

		public void DamageVehicle(VehicleController vehicle)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (vehicle.carDestroyed)
			{
				markedForRemoval.Add(((Component)vehicle).gameObject);
				return;
			}
			VehicleControllerPatch.DealPermanentDamage(vehicle, vehicleTargets.GetTotalDamage(damageMultiplier), CalcHitDir(((Component)vehicle).transform));
			vehicleTargets.hitEvent.Invoke(vehicle);
			if (((NetworkBehaviour)vehicle).IsOwner && vehicle.carDestroyed && (Object)(object)DamageTriggerNetworking != (Object)null)
			{
				DamageTriggerNetworking.DamageTriggerKilledServerRpc(2);
			}
			if (vehicleTargets.playCustomSounds)
			{
				PlayCustomAudio();
			}
		}

		public void SetVehicleDamage(int damage)
		{
			vehicleTargets.damage = damage;
		}

		public void DamageObject(IHittable obj)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			int totalDamage = objectTargets.GetTotalDamage(damageMultiplier);
			MonoBehaviour val = (MonoBehaviour)(object)((obj is MonoBehaviour) ? obj : null);
			obj.Hit(totalDamage, CalcHitDir((val != null) ? ((Component)val).transform : ((Component)this).transform), (PlayerControllerB)null, playNormalDamageSFX, -1);
			objectTargets.hitEvent.Invoke(obj);
			if (objectTargets.playCustomSounds)
			{
				PlayCustomAudio();
			}
		}

		public void SetObjectDamage(int damage)
		{
			objectTargets.damage = damage;
		}

		private void PlayCustomAudio()
		{
			if (clips.Length != 0 && sources.Length != 0)
			{
				AudioClip clip = clips[Random.Range(0, clips.Length)];
				AudioSource[] array = sources;
				foreach (AudioSource val in array)
				{
					val.clip = clip;
					val.Play();
				}
			}
		}
	}
	public class DamageTriggerNetworking : NetworkBehaviour
	{
		private class PlayerCorpse
		{
			public PlayerControllerB player;

			public float startTime = 0f;

			public float stickTime = 0f;

			public bool permaStuck = false;

			private bool stuck = false;

			private bool initialized = false;

			public bool Update(DamageTrigger trigger)
			{
				if (permaStuck && initialized)
				{
					return true;
				}
				if ((Object)(object)player.deadBody != (Object)null)
				{
					if (!initialized)
					{
						if (trigger.corpseType < 0)
						{
							Object.Destroy((Object)(object)((Component)player.deadBody).gameObject);
							player.deadBody = null;
							return false;
						}
						if (permaStuck)
						{
							OverrideModel(trigger);
						}
						if (trigger.attachCorpseToPoint && (Object)(object)trigger.corpseAttachPoint != (Object)null)
						{
							JLogHelper.LogInfo("Attatching " + player.playerUsername + "'s corpse to " + ((Object)trigger.corpseAttachPoint).name);
							player.deadBody.matchPositionExactly = trigger.matchPointExactly;
							player.deadBody.attachedTo = trigger.corpseAttachPoint;
							player.deadBody.attachedLimb = player.deadBody.bodyParts[(int)trigger.connectedBone];
							stuck = true;
						}
						initialized = true;
					}
					if (!(stickTime > 0f))
					{
						OverrideModel(trigger);
						return false;
					}
					if (stuck)
					{
						stickTime -= Time.deltaTime;
					}
					if (stickTime <= 0f)
					{
						DetachCorpse();
					}
				}
				else if (Time.realtimeSinceStartup - startTime > 2f)
				{
					JLogHelper.LogInfo("Player Corpse could not be found after two seconds!");
					return false;
				}
				return true;
			}

			public void OverrideModel(DamageTrigger trigger)
			{
				if ((Object)(object)trigger.OverrideCorpseMesh != (Object)null)
				{
					player.deadBody.ChangeMesh(trigger.OverrideCorpseMesh, (Material)null);
				}
			}

			public void DetachCorpse()
			{
				JLogHelper.LogInfo("Releasing " + player.playerUsername + "'s corpse");
				player.deadBody.matchPositionExactly = false;
				player.deadBody.attachedTo = null;
				player.deadBody.attachedLimb = null;
				stuck = false;
				permaStuck = false;
				stickTime = 0f;
			}
		}

		public DamageTrigger DamageTrigger;

		[Tooltip("Warning!\nThe player will be dead at the time of this event. Be careful what you do when passing a player to another method that you don't break anything.")]
		public InteractEvent PlayerKilled = new InteractEvent();

		public UnityEvent EnemyKilled = new UnityEvent();

		public UnityEvent VehicleKilled = new UnityEvent();

		private readonly List<PlayerCorpse> playerCorpses = new List<PlayerCorpse>();

		private readonly List<PlayerCorpse> removeCorpses = new List<PlayerCorpse>();

		private void Update()
		{
			if ((Object)(object)DamageTrigger == (Object)null || playerCorpses.Count <= 0)
			{
				return;
			}
			for (int i = 0; i < playerCorpses.Count; i++)
			{
				if (!playerCorpses[i].Update(DamageTrigger))
				{
					removeCorpses.Add(playerCorpses[i]);
				}
			}
			for (int j = 0; j < removeCorpses.Count; j++)
			{
				playerCorpses.Remove(removeCorpses[j]);
			}
			removeCorpses.Clear();
		}

		[ServerRpc(RequireOwnership = false)]
		public void DamageTriggerKilledPlayerServerRpc(int playerTarget)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1067576157u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerTarget);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1067576157u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					DamageTriggerKilledClientRpc(0, playerTarget);
				}
			}
		}

		[ServerRpc(RequireOwnership = true)]
		public void DamageTriggerKilledServerRpc(int type)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Invalid comparison between Unknown and I4
			//IL_00a5: 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_00b3: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3711696475u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, type);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3711696475u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				DamageTriggerKilledClientRpc(type);
			}
		}

		[ClientRpc]
		private void DamageTriggerKilledClientRpc(int type, int playerTarget = -1)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3159405848u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, type);
				BytePacker.WriteValueBitPacked(val2, playerTarget);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3159405848u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			if ((Object)(object)DamageTrigger == (Object)null)
			{
				JLogHelper.LogWarning(((Object)this).name + " DamageTriggerNetworking is missing a linked DamageTrigger!");
				return;
			}
			switch (type)
			{
			case 0:
				if (playerTarget >= 0 && playerTarget < RoundManager.Instance.playersManager.allPlayerScripts.Length)
				{
					PlayerCorpse playerCorpse = new PlayerCorpse
					{
						player = StartOfRound.Instance.allPlayerScripts[playerTarget],
						startTime = Time.realtimeSinceStartup,
						stickTime = Mathf.Abs(DamageTrigger.corpseStickTime),
						permaStuck = (DamageTrigger.corpseStickTime < 0f)
					};
					playerCorpses.Add(playerCorpse);
					((UnityEvent<PlayerControllerB>)(object)PlayerKilled).Invoke(playerCorpse.player);
				}
				break;
			case 1:
				EnemyKilled.Invoke();
				break;
			case 2:
				VehicleKilled.Invoke();
				break;
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_DamageTriggerNetworking()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(1067576157u, new RpcReceiveHandler(__rpc_handler_1067576157));
			NetworkManager.__rpc_func_table.Add(3711696475u, new RpcReceiveHandler(__rpc_handler_3711696475));
			NetworkManager.__rpc_func_table.Add(3159405848u, new RpcReceiveHandler(__rpc_handler_3159405848));
		}

		private static void __rpc_handler_1067576157(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerTarget = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerTarget);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DamageTriggerNetworking)(object)target).DamageTriggerKilledPlayerServerRpc(playerTarget);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3711696475(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
			}
			else
			{
				int type = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref type);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DamageTriggerNetworking)(object)target).DamageTriggerKilledServerRpc(type);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3159405848(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0043: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int type = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref type);
				int playerTarget = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerTarget);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((DamageTriggerNetworking)(object)target).DamageTriggerKilledClientRpc(type, playerTarget);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "DamageTriggerNetworking";
		}
	}
	public class DamageZoneTrigger : MonoBehaviour
	{
		[Header("-=-DEPRICATED-=-")]
		[SerializeField]
		public CauseOfDeath damageSource = (CauseOfDeath)0;

		public Vector3 hitDir = Vector3.zero;

		public int corpseType = 0;

		[Header("Conditions")]
		public bool damageOnEnter = true;

		public bool damageOnExit = false;

		public bool damageOnCollision = true;

		[Header("Damage")]
		public bool damagePlayers = true;

		public int damageForPlayers = 1;

		public bool damageEnemies = true;

		public int damageForEnemies = 1;

		public bool damageVehicles = false;

		public int damageForVehicles = 1;

		public bool damageObjects = false;

		public int damageForObjects = 1;

		[Header("Continuous Damage")]
		public bool continuousDamage = true;

		public float hitInterval = 0.5f;

		private float timer = 0f;

		[Header("SFX")]
		public bool playNormalDamageSFX = true;

		public AudioClip[] clips = (AudioClip[])(object)new AudioClip[0];

		public AudioSource[] sources = (AudioSource[])(object)new AudioSource[0];

		[Header("Player")]
		public InteractEvent OnPlayerDamaged = new InteractEvent();

		private List<PlayerControllerB> playersInside = new List<PlayerControllerB>();

		private List<EnemyAI> creaturesInside = new List<EnemyAI>();

		private List<VehicleController> vehiclesInside = new List<VehicleController>();

		private List<IHittable> objectsInside = new List<IHittable>();

		public void OnTriggerEnter(Collider collider)
		{
			switch (DamageTarget(((Component)collider).gameObject, damageOnEnter))
			{
			case 0:
				playersInside.Add(((Component)collider).GetComponent<PlayerControllerB>());
				break;
			case 1:
				creaturesInside.Add(((Component)collider).GetComponent<EnemyAICollisionDetect>().mainScript);
				break;
			case 2:
				vehiclesInside.Add(((Component)collider).GetComponent<VehicleController>());
				break;
			case 3:
				objectsInside.Add(((Component)collider).GetComponent<IHittable>());
				break;
			}
		}

		public void OnTriggerExit(Collider collider)
		{
			switch (DamageTarget(((Component)collider).gameObject, damageOnExit))
			{
			case 0:
				playersInside.Remove(((Component)collider).GetComponent<PlayerControllerB>());
				break;
			case 1:
				creaturesInside.Remove(((Component)collider).GetComponent<EnemyAICollisionDetect>().mainScript);
				break;
			case 2:
				vehiclesInside.Remove(((Component)collider).GetComponent<VehicleController>());
				break;
			case 3:
				objectsInside.Remove(((Component)collider).GetComponent<IHittable>());
				break;
			}
		}

		public void OnCollisionEnter(Collision collision)
		{
			DamageTarget(collision.gameObject, damageOnCollision);
		}

		public void Update()
		{
			if (continuousDamage)
			{
				timer -= Time.deltaTime;
				if (timer <= 0f)
				{
					timer = hitInterval;
					DamageAllInside();
				}
			}
		}

		public void DamageAllInside()
		{
			if (damagePlayers)
			{
				for (int i = 0; i < playersInside.Count; i++)
				{
					if (!playersInside[i].isPlayerDead)
					{
						DamagePlayer(playersInside[i]);
					}
				}
			}
			if (damageEnemies)
			{
				for (int j = 0; j < creaturesInside.Count; j++)
				{
					if (!creaturesInside[j].isEnemyDead)
					{
						DamageEnemy(creaturesInside[j]);
					}
				}
			}
			if (damageVehicles)
			{
				for (int k = 0; k < vehiclesInside.Count; k++)
				{
					DamageVehicle(vehiclesInside[k]);
				}
			}
			if (damageObjects)
			{
				for (int l = 0; l < objectsInside.Count; l++)
				{
					DamageObject(objectsInside[l]);
				}
			}
		}

		private int DamageTarget(GameObject target, bool condition = true)
		{
			if (target.CompareTag("Player"))
			{
				PlayerControllerB val = default(PlayerControllerB);
				if (target.TryGetComponent<PlayerControllerB>(ref val))
				{
					if (condition && damagePlayers && !val.isPlayerDead)
					{
						DamagePlayer(val);
					}
					return 0;
				}
			}
			else if (target.CompareTag("Enemy"))
			{
				EnemyAICollisionDetect val2 = default(EnemyAICollisionDetect);
				if (target.TryGetComponent<EnemyAICollisionDetect>(ref val2))
				{
					if (condition && damageEnemies && !val2.mainScript.isEnemyDead)
					{
						DamageEnemy(val2.mainScript);
					}
					return 1;
				}
			}
			else
			{
				VehicleController val3 = default(VehicleController);
				if (target.TryGetComponent<VehicleController>(ref val3))
				{
					if (condition && damageVehicles && !val3.carDestroyed)
					{
						DamageVehicle(val3);
					}
					return 2;
				}
				IHittable obj = default(IHittable);
				if (target.TryGetComponent<IHittable>(ref obj))
				{
					if (condition && damageObjects)
					{
						DamageObject(obj);
					}
					return 3;
				}
			}
			return -1;
		}

		public void DamagePlayer(PlayerControllerB player, bool playCustomAudio = true)
		{
			//IL_0009: 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_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_001d: 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)
			int num = damageForPlayers;
			CauseOfDeath val = damageSource;
			Vector3 val2 = hitDir;
			player.DamagePlayer(num, playNormalDamageSFX, true, val, Mathf.Clamp(corpseType, 0, StartOfRound.Instance.playerRagdolls.Count), false, val2);
			if (playCustomAudio)
			{
				PlayCustomAudio();
			}
			((UnityEvent<PlayerControllerB>)(object)OnPlayerDamaged).Invoke(player);
		}

		public void DamageEnemy(EnemyAI enemy, bool playCustomAudio = true)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			enemy.HitEnemyOnLocalClient(damageForEnemies, hitDir, (PlayerControllerB)null, playNormalDamageSFX, -1);
			if (playCustomAudio)
			{
				PlayCustomAudio();
			}
		}

		public void DamageVehicle(VehicleController vehicle, bool playCustomAudio = true)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			VehicleControllerPatch.DealPermanentDamage(vehicle, damageForVehicles, hitDir);
			if (playCustomAudio)
			{
				PlayCustomAudio();
			}
		}

		public void DamageObject(IHittable obj, bool playCustomAudio = true)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			obj.Hit(damageForObjects, hitDir, (PlayerControllerB)null, playNormalDamageSFX, -1);
			if (playCustomAudio)
			{
				PlayCustomAudio();
			}
		}

		private void PlayCustomAudio()
		{
			if (clips.Length != 0 && sources.Length != 0)
			{
				AudioClip clip = clips[Random.Range(0, clips.Length)];
				AudioSource[] array = sources;
				foreach (AudioSource val in array)
				{
					val.clip = clip;
					val.Play();
				}
			}
		}
	}
	[RequireComponent(typeof(Animator))]
	public class DayCycleAnimator : MonoBehaviour
	{
		private Animator anim;

		[Tooltip("Scale of time the animation synced to the day progression will use. A value of 1 plays the animation from beginning to end once. Numbers larger than 1 requires the animation to have looping enabled otherwise it will stop on the final frame.")]
		[FormerlySerializedAs("timeScale")]
		public float fixedAnimEndTime = 1f;

		public void Start()
		{
			anim = ((Component)this).GetComponent<Animator>();
		}

		public void FixedUpdate()
		{
			float num = Mathf.Max(0f, TimeOfDay.Instance.currentDayTime - 100f);
			float num2 = num / TimeOfDay.Instance.totalTime;
			anim.SetFloat("time", num2 * fixedAnimEndTime);
		}

		public void SetFixedAnimTime(float time)
		{
			fixedAnimEndTime = time;
		}
	}
	public class DelayScript : MonoBehaviour
	{
		public class QueuedEvent
		{
			public PlayerControllerB? target = null;

			public float timer;
		}

		[FormerlySerializedAs("waitOnAwake")]
		public bool waitOnEnabled = false;

		public bool clearOnDisable = false;

		public float delaySeconds = 2f;

		[Tooltip("Event run after StartWaiting() is called by another event.")]
		public UnityEvent events = new UnityEvent();

		[Tooltip("Only gets triggered if a player is given on the StartWaiting() call.")]
		public InteractEvent playerEvents = new InteractEvent();

		private readonly List<QueuedEvent> queuedEvents = new List<QueuedEvent>();

		private readonly List<QueuedEvent> expiredEvents = new List<QueuedEvent>();

		public void OnEnable()
		{
			if (waitOnEnabled)
			{
				StartWaiting();
			}
		}

		public void OnDisable()
		{
			if (clearOnDisable)
			{
				ClearEventQueue();
			}
		}

		public void Update()
		{
			for (int i = 0; i < queuedEvents.Count; i++)
			{
				queuedEvents[i].timer -= Time.deltaTime;
				if (queuedEvents[i].timer <= 0f)
				{
					expiredEvents.Add(queuedEvents[i]);
				}
			}
			if (expiredEvents.Count <= 0)
			{
				return;
			}
			for (int j = 0; j < expiredEvents.Count; j++)
			{
				events.Invoke();
				if ((Object)(object)expiredEvents[j].target != (Object)null)
				{
					((UnityEvent<PlayerControllerB>)(object)playerEvents).Invoke(expiredEvents[j].target);
				}
				queuedEvents.Remove(expiredEvents[j]);
			}
			expiredEvents.Clear();
		}

		public void StartWaiting(PlayerControllerB player)
		{
			queuedEvents.Add(new QueuedEvent
			{
				timer = delaySeconds,
				target = player
			});
		}

		public void StartWaiting()
		{
			JLogHelper.LogInfo($"{((Object)this).name} started waiting {delaySeconds}");
			queuedEvents.Add(new QueuedEvent
			{
				timer = delaySeconds
			});
		}

		public void ClearEventQueue()
		{
			queuedEvents.Clear();
		}
	}
	public class EnemySpawner : MonoBehaviour
	{
		[Serializable]
		public class WeightedEnemyRefrence
		{
			public string enemyName = "";

			public EnemyType enemyType;

			[Range(0f, 100f)]
			public int rarity;
		}

		[Tooltip("Determines weather to spawn a random enemy from the pool or to spawn the specified type")]
		public bool spawnRandom = false;

		public RotationType spawnRotation = RotationType.ObjectRotation;

		public List<WeightedEnemyRefrence> randomPool = new List<WeightedEnemyRefrence>();

		public string enemyName = "";

		public EnemyType? type;

		[Tooltip("Ran after an enemy spawns. Enemy provided is the one that was just spawned.")]
		public EnemyEvent SpawnedEvent = new EnemyEvent();

		[Header("NavMesh")]
		[Tooltip("The max distance from this transform that a navmesh will be found")]
		public float navMeshRange = 10f;

		[Header("Misc")]
		[FormerlySerializedAs("spawnOnAwake")]
		public bool spawnOnEnable = false;

		public bool checkRegistry = true;

		public bool respectEnemyCap = false;

		public PowerCap respectPowerCap = PowerCap.None;

		public static float GetRot(RotationType rotation, float yRot = 0f)
		{
			if (1 == 0)
			{
			}
			float result = rotation switch
			{
				RotationType.ObjectRotation => yRot, 
				RotationType.RandomRotation => Random.Range(0f, 360f), 
				_ => 0f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static Quaternion GetRot(RotationType rotation, Quaternion refrence)
		{
			//IL_0010: 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_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_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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (1 == 0)
			{
			}
			Quaternion result = (Quaternion)(rotation switch
			{
				RotationType.ObjectRotation => refrence, 
				RotationType.RandomRotation => Quaternion.Euler(0f, Random.Range(0f, 360f), 0f), 
				_ => Quaternion.identity, 
			});
			if (1 == 0)
			{
			}
			return result;
		}

		public void Awake()
		{
			if (!checkRegistry)
			{
				return;
			}
			if (!string.IsNullOrEmpty(enemyName))
			{
				type = JLevelPropertyRegistry.GetRegisteredEnemy(enemyName);
			}
			else if ((Object)(object)type != (Object)null)
			{
				type = JLevelPropertyRegistry.GetRegisteredEnemy(type);
			}
			if (randomPool.Count > 0)
			{
				for (int i = 0; i < randomPool.Count; i++)
				{
					if (!string.IsNullOrEmpty(randomPool[i].enemyName))
					{
						EnemyType registeredEnemy = JLevelPropertyRegistry.GetRegisteredEnemy(randomPool[i].enemyName);
						if ((Object)(object)registeredEnemy != (Object)null)
						{
							randomPool[i].enemyType = registeredEnemy;
						}
					}
					else if ((Object)(object)randomPool[i].enemyType != (Object)null)
					{
						randomPool[i].enemyType = JLevelPropertyRegistry.GetRegisteredEnemy(randomPool[i].enemyType);
					}
					else
					{
						JLogHelper.LogWarning($"({((Object)this).name}) Enemy spawner is missing enemy at {i}", JLogLevel.Debuging);
					}
				}
			}
			else
			{
				for (int j = 0; j < JLevelPropertyRegistry.AllSortedEnemies.Count; j++)
				{
					WeightedEnemyRefrence item = new WeightedEnemyRefrence
					{
						enemyType = JLevelPropertyRegistry.AllSortedEnemies[j],
						rarity = 10
					};
					randomPool.Add(item);
				}
			}
			checkRegistry = false;
		}

		public void OnEnable()
		{
			if (spawnOnEnable)
			{
				SpawnEnemy();
			}
		}

		public void SpawnEnemy()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SpawnEnemy(((Component)this).transform.position);
		}

		public void SpawnEnemy(GameObject target)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SpawnEnemy(target.transform.position);
		}

		public void SpawnEnemy(MonoBehaviour target)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SpawnEnemy(((Component)target).transform.position);
		}

		public void SpawnEnemy(Vector3 pos)
		{
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: 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)
			//IL_01ae: 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_01da: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)RoundManager.Instance).IsHost && !((NetworkBehaviour)RoundManager.Instance).IsServer)
			{
				return;
			}
			EnemyType enemyType;
			if (spawnRandom)
			{
				int weightedIndex = GetWeightedIndex();
				JLogHelper.LogInfo($"({((Object)this).name}) Attempting to spawn enemy at index {weightedIndex}");
				enemyType = randomPool[weightedIndex].enemyType;
			}
			else
			{
				enemyType = type;
			}
			if ((Object)(object)enemyType != (Object)null)
			{
				if (respectEnemyCap && enemyType.numberSpawned > enemyType.MaxCount)
				{
					return;
				}
				float powerLevel = enemyType.PowerLevel;
				PowerCap powerCap = respectPowerCap;
				if (1 == 0)
				{
				}
				float num = powerCap switch
				{
					PowerCap.Indoor => RoundManager.Instance.currentMaxInsidePower - RoundManager.Instance.currentEnemyPower, 
					PowerCap.Daytime => (float)RoundManager.Instance.currentLevel.maxDaytimeEnemyPowerCount - RoundManager.Instance.currentDaytimeEnemyPower, 
					PowerCap.Nighttime => RoundManager.Instance.currentMaxOutsidePower - RoundManager.Instance.currentOutsideEnemyPower, 
					_ => 1000000f, 
				};
				if (1 == 0)
				{
				}
				if (powerLevel > num || !((Object)(object)enemyType.enemyPrefab != (Object)null))
				{
					return;
				}
				bool flag;
				NavMeshHit val = default(NavMeshHit);
				if ((flag = NavMesh.SamplePosition(pos, ref val, navMeshRange, -1)) || navMeshRange < 0f)
				{
					JLogHelper.LogInfo($"({((Object)this).name}) Spawning: {enemyType.enemyName} at {pos}");
					GameObject val2 = NetworkObjectReference.op_Implicit(RoundManager.Instance.SpawnEnemyGameObject(flag ? ((NavMeshHit)(ref val)).position : pos, GetRot(spawnRotation, ((Component)((Component)this).transform).transform.eulerAngles.y), 0, enemyType));
					EnemyAI val3 = default(EnemyAI);
					if (val2.TryGetComponent<EnemyAI>(ref val3))
					{
						((UnityEvent<EnemyAI>)(object)SpawnedEvent).Invoke(val3);
					}
				}
				else
				{
					JLogHelper.LogInfo("(" + ((Object)this).name + ") Failed to spawn. (Couldn't Find NavMesh. If try increasing the EnemySpawner's navMeshDistance if you're having an issue.)");
				}
			}
			else
			{
				JLogHelper.LogWarning("(" + ((Object)this).name + ") Enemy Spawner tried to spawn a null EnemyType!");
			}
		}

		private int GetWeightedIndex()
		{
			int num = 0;
			for (int i = 0; i < randomPool.Count; i++)
			{
				num += randomPool[i].rarity;
			}
			int num2 = Random.Range(0, num);
			for (int j = 0; j < randomPool.Count; j++)
			{
				num2 -= randomPool[j].rarity;
				if (num2 <= 0)
				{
					return j;
				}
			}
			return Random.Range(0, randomPool.Count);
		}
	}
	public enum ColliderType
	{
		Unknown = -1,
		Player,
		Enemy,
		Vehicle,
		Object
	}
	public enum PlayerBone
	{
		Base = 6,
		Neck = 0,
		Spine = 5,
		RightArmUpper = 9,
		LeftArmUpper = 10,
		RightArmLower = 1,
		LeftArmLower = 2,
		RightThigh = 7,
		LeftThigh = 8,
		RightShin = 3,
		LeftShin = 4
	}
	public enum RotationType
	{
		ObjectRotation,
		RandomRotation,
		NoRotation
	}
	public enum PowerCap
	{
		None,
		Indoor,
		Daytime,
		Nighttime
	}
	public enum SpawnPoolSource
	{
		CustomList,
		AllItems,
		LevelItems,
		StoreItems
	}
	public enum ActiveCondition
	{
		None,
		ActiveOutdoors,
		ActiveIndoors,
		ActiveOutdoorsOutsideShip
	}
	public enum SpawnRotation
	{
		Random,
		FacingWall,
		FacingAwayFromWall,
		BackToWall
	}
	public enum SpawnNodes
	{
		Children,
		OutsideAINodes,
		InsideAINodes,
		AINodes
	}
	public enum NavMeshToRebake
	{
		None = 0,
		Exterior = 1,
		Custom = -1
	}
	public enum RandomTeleportRegion
	{
		Indoor,
		Outdoor,
		Moon,
		Nearby,
		RandomPlayer
	}
	public enum Region
	{
		None,
		Outdoor,
		Indoor
	}
	public enum TeleportEffect
	{
		None,
		ShipTeleport,
		InverseTeleport
	}
	public enum PlayerTarget
	{
		Local,
		Closest,
		Farthest
	}
	public class EventLimiter : MonoBehaviour
	{
		public int maxTriggers = 1;

		public UnityEvent Event = new UnityEvent();

		public InteractEvent PlayerEvent = new InteractEvent();

		public void Trigger()
		{
			Trigger(null);
		}

		public void Trigger(PlayerControllerB? player)
		{
			if (maxTriggers > 0)
			{
				maxTriggers--;
				Event.Invoke();
				if ((Object)(object)player != (Object)null)
				{
					((UnityEvent<PlayerControllerB>)(object)PlayerEvent).Invoke(player);
				}
			}
		}

		public void AddUses(int num)
		{
			maxTriggers += num;
		}

		public void SetUses(int num)
		{
			maxTriggers = num;
		}
	}
	public class ExplosiveEmitter : MonoBehaviour
	{
		[Header("Explosion Size")]
		[FormerlySerializedAs("explodeOnAwake")]
		public bool explodeOnEnabled = false;

		public float killDistance = 5.7f;

		public float damageRange = 6f;

		[Header("Damage Properties")]
		public int nonLethalDamage = 50;

		public float pushForce = 0f;

		public bool goThroughCar = false;

		public GameObject? overrideEffect = null;

		public bool spawnParticles = true;

		[Header("Screen Shake Emmision")]
		[FormerlySerializedAs("shakeOnAwake")]
		public bool shakeOnEnabled = false;

		[Tooltip("Bridge Destroyed Default: 30")]
		public float strongDistance = -1f;

		[Tooltip("Bridge Destroyed Default: 50")]
		public float longDistance = -1f;

		[Tooltip("Landmine Default: 14")]
		public float bigDistance = 14f;

		[Tooltip("Landmine Default = 25")]
		public float smallDistance = 25f;

		[Header("Stun Explosion")]
		[FormerlySerializedAs("stunOnAwake")]
		public bool stunOnEnabled = false;

		public bool affectAudio = true;

		public float flashSeverityMultiplier = 1f;

		public float enemyStunTime = 7.5f;

		public float flashSeverityDistanceRolloff = 1f;

		public void OnEnabled()
		{
			if (explodeOnEnabled)
			{
				Explode();
			}
			if (shakeOnEnabled)
			{
				DistanceShakeScreen();
			}
			if (stunOnEnabled)
			{
				StunFlash();
			}
		}

		public void Explode()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Explode(((Component)this).transform.position);
		}

		public void Explode(MonoBehaviour target)
		{
			Explode(((Component)target).gameObject);
		}

		public void Explode(GameObject target)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Explode(target.transform.position);
		}

		public void Explode(Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Landmine.SpawnExplosion(position, spawnParticles, killDistance, damageRange, nonLethalDamage, pushForce, overrideEffect, goThroughCar);
		}

		private void OnDrawGizmosSelected()
		{
			//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)
			//IL_0048: 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_007d: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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_00f8: 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_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_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			if (killDistance > 0f)
			{
				Gizmos.color = Color.red;
				Gizmos.DrawWireSphere(((Component)this).transform.position, killDistance);
			}
			if (damageRange > 0f)
			{
				Gizmos.color = Color.yellow;
				Gizmos.DrawWireSphere(((Component)this).transform.position, damageRange);
			}
			if (strongDistance > 0f)
			{
				Gizmos.color = Color.black;
				Gizmos.DrawWireSphere(((Component)this).transform.position, strongDistance);
			}
			if (longDistance > 0f)
			{
				Gizmos.color = Color.Lerp(Color.black, Color.gray, 0.5f);
				Gizmos.DrawWireSphere(((Component)this).transform.position, longDistance);
			}
			if (bigDistance > 0f)
			{
				Gizmos.color = Color.gray;
				Gizmos.DrawWireSphere(((Component)this).transform.position, bigDistance);
			}
			if (smallDistance > 0f)
			{
				Gizmos.color = Color.Lerp(Color.gray, Color.white, 0.5f);
				Gizmos.DrawWireSphere(((Component)this).transform.position, smallDistance);
			}
		}

		private float GetLocalPlayerDistance()
		{
			//IL_0010: 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)
			return Vector3.Distance(((Component)GameNetworkManager.Instance.localPlayerController).transform.position, ((Component)this).transform.position);
		}

		public void DistanceShakeScreen()
		{
			float localPlayerDistance = GetLocalPlayerDistance();
			if (strongDistance > 0f && localPlayerDistance < strongDistance)
			{
				HUDManager.Instance.ShakeCamera((ScreenShakeType)3);
			}
			else if (longDistance > 0f && localPlayerDistance < longDistance)
			{
				HUDManager.Instance.ShakeCamera((ScreenShakeType)2);
			}
			else if (bigDistance > 0f && localPlayerDistance < bigDistance)
			{
				HUDManager.Instance.ShakeCamera((ScreenShakeType)1);
			}
			else if (smallDistance > 0f && localPlayerDistance < smallDistance)
			{
				HUDManager.Instance.ShakeCamera((ScreenShakeType)0);
			}
		}

		public void ShakeLocalClient(int intensity)
		{
			if (Enum.IsDefined(typeof(ScreenShakeType), intensity))
			{
				HUDManager.Instance.ShakeCamera((ScreenShakeType)intensity);
			}
		}

		public void StunFlash()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			StunFlash(((Component)this).transform.position);
		}

		public void StunFlash(MonoBehaviour target)
		{
			StunFlash(((Component)target).gameObject);
		}

		public void StunFlash(GameObject target)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			StunFlash(target.transform.position);
		}

		public void StunFlash(Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			StunGrenadeItem.StunExplosion(position, affectAudio, flashSeverityMultiplier, enemyStunTime, flashSeverityDistanceRolloff, false, (PlayerControllerB)null, (PlayerControllerB)null, 0f);
		}
	}
	public class ExtendedLevelLocker : MonoBehaviour
	{
		public string sceneName;

		[Header("OnTriggerEnter")]
		public bool isTriggerActivated = false;

		public bool shouldUnlock = true;

		public void SetLevelLocked(bool locked)
		{
			if (JCompatabilityHelper.IsLoaded(JCompatabilityHelper.CachedMods.LethalLevelLoader))
			{
				LLLHelper.LockExtendedLevel(sceneName, locked);
			}
		}

		public void SetLevelHidden(bool hidden)
		{
			if (JCompatabilityHelper.IsLoaded(JCompatabilityHelper.CachedMods.LethalLevelLoader))
			{
				LLLHelper.HideExtendedLevel(sceneName, hidden);
			}
		}

		public void LockLevel(string sceneName)
		{
			if (JCompatabilityHelper.IsLoaded(JCompatabilityHelper.CachedMods.LethalLevelLoader))
			{
				LLLHelper.LockExtendedLevel(sceneName, !shouldUnlock);
			}
		}

		public void HideLevel(string sceneName)
		{
			if (JCompatabilityHelper.IsLoaded(JCompatabilityHelper.CachedMods.LethalLevelLoader))
			{
				LLLHelper.HideExtendedLevel(sceneName, !shouldUnlock);
			}
		}

		public void OnTriggerEnter(Collider other)
		{
			if (isTriggerActivated && ((Component)other).CompareTag("Player"))
			{
				SetLevelLocked(!shouldUnlock);
			}
		}
	}
	public interface IDungeonLoadListener
	{
		void PostDungeonGeneration();
	}
	public interface IWeightedItem
	{
		int GetWeight();

		static int GetRandomIndex(IWeightedItem[] weightedItems)
		{
			IWeightedItem[] weightedItems2 = weightedItems;
			return GetRandomIndex(Random.Range(0, weightedItems2.CombinedWeights() + 1), weightedItems2, () => Random.Range(0, weightedItems2.Length));
		}

		static int GetRandomIndex(Random random, IWeightedItem[] weightedItems)
		{
			Random random2 = random;
			IWeightedItem[] weightedItems2 = weightedItems;
			return GetRandomIndex(random2.Next(0, weightedItems2.CombinedWeights() + 1), weightedItems2, () => random2.Next(0, weightedItems2.Length));
		}

		private static int GetRandomIndex(int random, IWeightedItem[] weightedItems, Func<int> failState)
		{
			for (int i = 0; i < weightedItems.Length; i++)
			{
				random -= weightedItems[i].GetWeight();
				if (random <= 0)
				{
					return i;
				}
			}
			return failState();
		}
	}
	public class InventoryRemover : MonoBehaviour
	{
		public string[] itemsToRemove;

		public ItemFilter.Properties[] removeByFilter = new ItemFilter.Properties[0];

		public bool removeAllInstances = false;

		public void RemoveItems(PlayerControllerB player)
		{
			for (int i = 0; i < player.ItemSlots.Length && ((Object)(object)player.ItemSlots[i] == (Object)null || !CheckSlot(player, i) || removeAllInstances); i++)
			{
			}
		}

		public void ClearInventory(PlayerControllerB player)
		{
			for (int i = 0; i < player.ItemSlots.Length; i++)
			{
				if (!((Object)(object)player.ItemSlots[i] == (Object)null))
				{
					player.DestroyItemInSlotAndSync(i);
				}
			}
		}

		public void RemoveHeld(PlayerControllerB player)
		{
			if ((Object)(object)player.currentlyHeldObjectServer != (Object)null)
			{
				CheckSlot(player, player.currentItemSlot);
			}
		}

		private bool CheckSlot(PlayerControllerB player, int slot)
		{
			for (int i = 0; i < itemsToRemove.Length; i++)
			{
				if (player.ItemSlots[slot].itemProperties.itemName.ToLower() == itemsToRemove[i].ToLower())
				{
					player.DestroyItemInSlotAndSync(slot);
					return true;
				}
			}
			for (int j = 0; j < removeByFilter.Length; j++)
			{
				if (removeByFilter[j].Check(player.ItemSlots[slot]))
				{
					player.DestroyItemInSlotAndSync(slot);
					return true;
				}
			}
			return false;
		}
	}
	public class ItemConsumer : NetworkBehaviour
	{
		public Item[] validItems = (Item[])(object)new Item[0];

		public bool checkExact = false;

		public ItemFilter.Properties[] validItemFilters = new ItemFilter.Properties[0];

		public InteractEvent OnSuccess = new InteractEvent();

		public bool runEventOnAllClients = true;

		public void CheckHeldItem(PlayerControllerB player)
		{
			CheckItemServerRpc(player.Index());
		}

		[ServerRpc(RequireOwnership = false)]
		private void CheckItemServerRpc(int playerWhoSent)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2913302232u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerWhoSent);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2913302232u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			PlayerControllerB val3 = RoundManager.Instance.playersManager.allPlayerScripts[playerWhoSent];
			if ((Object)(object)val3.currentlyHeldObjectServer == (Object)null)
			{
				return;
			}
			GrabbableObject currentlyHeldObjectServer = val3.currentlyHeldObjectServer;
			int num = 0;
			while (true)
			{
				if (num < validItems.Length)
				{
					if (checkExact ? ((Object)(object)currentlyHeldObjectServer.itemProperties == (Object)(object)validItems[num]) : (currentlyHeldObjectServer.itemProperties.itemName == validItems[num].itemName))
					{
						break;
					}
					num++;
					continue;
				}
				int num2 = 0;
				while (true)
				{
					if (num2 < validItemFilters.Length)
					{
						if (validItemFilters[num2].Check(currentlyHeldObjectServer))
						{
							break;
						}
						num2++;
						continue;
					}
					return;
				}
				break;
			}
			RemoveItemFromClientRpc(playerWhoSent);
		}

		[ClientRpc]
		private void RemoveItemFromClientRpc(int playerWhoSent)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: 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_0071: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2753840628u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerWhoSent);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2753840628u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				PlayerControllerB val3 = RoundManager.Instance.playersManager.allPlayerScripts[playerWhoSent];
				bool flag = val3.IsLocalPlayer();
				if (flag)
				{
					val3.DestroyItemInSlotAndSync(val3.currentItemSlot);
				}
				if (runEventOnAllClients || flag)
				{
					((UnityEvent<PlayerControllerB>)(object)OnSuccess).Invoke(val3);
				}
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_ItemConsumer()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(2913302232u, new RpcReceiveHandler(__rpc_handler_2913302232));
			NetworkManager.__rpc_func_table.Add(2753840628u, new RpcReceiveHandler(__rpc_handler_2753840628));
		}

		private static void __rpc_handler_2913302232(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerWhoSent = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerWhoSent);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ItemConsumer)(object)target).CheckItemServerRpc(playerWhoSent);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2753840628(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerWhoSent = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerWhoSent);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((ItemConsumer)(object)target).RemoveItemFromClientRpc(playerWhoSent);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "ItemConsumer";
		}
	}
	public class ItemSpawner : MonoBehaviour
	{
		[Serializable]
		public class WeightedItemRefrence : IWeightedItem
		{
			[Range(0f, 100f)]
			public int Weight = 20;

			public string ItemName = "";

			public Item Item;

			public bool FindRegisteredItem = true;

			public bool OverrideValue = false;

			public int ScrapValue = 0;

			public Vector3 SpawnOffset = Vector3.zero;

			public int GetWeight()
			{
				return Weight;
			}

			public void FindRegistered()
			{
				if (ItemName != "")
				{
					foreach (Item items in RoundManager.Instance.playersManager.allItemsList.itemsList)
					{
						if (ItemName == items.itemName)
						{
							Item = items;
							break;
						}
					}
					return;
				}
				if (!FindRegisteredItem || !((Object)(object)Item != (Object)null))
				{
					return;
				}
				foreach (Item items2 in RoundManager.Instance.playersManager.allItemsList.itemsList)
				{
					if (Item.itemName == items2.itemName)
					{
						Item = items2;
						break;
					}
				}
			}
		}

		[FormerlySerializedAs("spawnOnAwake")]
		public bool spawnOnEnabled = true;

		public RotationType spawnRotation = RotationType.NoRotation;

		public SpawnPoolSource SourcePool = SpawnPoolSource.CustomList;

		public WeightedItemRefrence[] CustomList = new WeightedItemRefrence[1]
		{
			new WeightedItemRefrence()
		};

		private bool checkRegistry = true;

		public void Awake()
		{
			if (checkRegistry)
			{
				WeightedItemRefrence[] customList = CustomList;
				foreach (WeightedItemRefrence weightedItemRefrence in customList)
				{
					weightedItemRefrence.FindRegistered();
				}
				checkRegistry = false;
			}
		}

		public void OnEnable()
		{
			if (spawnOnEnabled)
			{
				SpawnRandom();
			}
		}

		public static Item? GetRandomItem(SpawnPoolSource source, out int overrideValue, out Vector3 offset, WeightedItemRefrence[]? weightedItems = null)
		{
			//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_0078: 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)
			Item result = null;
			overrideValue = -1;
			offset = Vector3.zero;
			switch (source)
			{
			case SpawnPoolSource.CustomList:
				if (weightedItems != null && weightedItems.Length != 0)
				{
					WeightedItemRefrence weightedRandom = weightedItems.GetWeightedRandom();
					result = weightedRandom.Item;
					if (weightedRandom.OverrideValue)
					{
						overrideValue = weightedRandom.ScrapValue;
					}
					offset = weightedRandom.SpawnOffset;
				}
				break;
			case SpawnPoolSource.AllItems:
				result = StartOfRound.Instance.allItemsList.itemsList[Random.Range(0, StartOfRound.Instance.allItemsList.itemsList.Count)];
				break;
			case SpawnPoolSource.LevelItems:
			{
				List<WeightedItemRefrence> list = new List<WeightedItemRefrence>();
				foreach (SpawnableItemWithRarity item in RoundManager.Instance.currentLevel.spawnableScrap)
				{
					list.Add(new WeightedItemRefrence
					{
						Item = item.spawnableItem,
						Weight = item.rarity
					});
				}
				result = list.GetWeightedRandom().Item;
				break;
			}
			case SpawnPoolSource.StoreItems:
			{
				Terminal terminal = JLevelPropertyRegistry.GetTerminal();
				if ((Object)(object)terminal != (Object)null)
				{
					result = terminal.buyableItemsList[Random.Range(0, terminal.buyableItemsList.Length)];
				}
				break;
			}
			}
			return result;
		}

		public void SpawnRandom(int count = 1)
		{
			//IL_000d: 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)
			SpawnRandomItems(SourcePool, ((Component)this).transform.position, RoundManager.Instance.spawnedScrapContainer, ((Component)this).transform.rotation, CustomList, null, count, spawnOnNetwork: true, spawnRotation);
		}

		public void SpawnRandom(MonoBehaviour target)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SpawnRandom(((Component)target).transform.position);
		}

		public void SpawnRandom(GameObject target)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SpawnRandom(target.transform.position);
		}

		public void SpawnRandom(Vector3 pos)
		{
			//IL_0007: 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)
			SpawnRandomItems(SourcePool, pos, RoundManager.Instance.spawnedScrapContainer, ((Component)this).transform.rotation, CustomList, null, 1, spawnOnNetwork: true, spawnRotation);
		}

		public static List<KeyValuePair<GrabbableObject, int>> SpawnRandomItems(SpawnPoolSource sourcePool, Vector3 position, Transform parent, Quaternion sourceRot, WeightedItemRefrence[]? customList = null, Vector3[]? offsets = null, int count = 1, bool spawnOnNetwork = true, RotationType rotation = RotationType.NoRotation)
		{
			//IL_0095: 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_0098: 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_0082: 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_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)
			List<KeyValuePair<GrabbableObject, int>> list = new List<KeyValuePair<GrabbableObject, int>>();
			if (((NetworkBehaviour)RoundManager.Instance).IsServer || ((NetworkBehaviour)RoundManager.Instance).IsHost)
			{
				if (customList == null)
				{
					customList = new WeightedItemRefrence[0];
				}
				if (offsets == null)
				{
					offsets = (Vector3[]?)(object)new Vector3[0];
				}
				for (int i = 0; i < count; i++)
				{
					int overrideValue;
					Vector3 offset;
					Item randomItem = GetRandomItem(sourcePool, out overrideValue, out offset, customList);
					if ((Object)(object)randomItem != (Object)null && (Object)(object)randomItem.spawnPrefab != (Object)null)
					{
						if (offsets.Length > i)
						{
							offset += offsets[i];
						}
						GrabbableObject val = SpawnItem(randomItem, position + offset, parent, sourceRot, overrideValue, spawnOnNetwork, rotation);
						if ((Object)(object)val != (Object)null)
						{
							list.Add(new KeyValuePair<GrabbableObject, int>(val, overrideValue));
						}
					}
				}
			}
			return list;
		}

		public static GrabbableObject? SpawnItem(Item item, Vector3 pos, Transform? parent, Quaternion sourceRot, int overrideValue = -1, bool spawnOnNetwork = true, RotationType rotation = RotationType.NoRotation)
		{
			//IL_003d: 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)
			JLogHelper.LogInfo($"Spawn on network: {spawnOnNetwork}", JLogLevel.Wesley);
			if (((NetworkBehaviour)RoundManager.Instance).IsServer || ((NetworkBehaviour)RoundManager.Instance).IsHost)
			{
				GrabbableObject component = Object.Instantiate<GameObject>(item.spawnPrefab, pos, EnemySpawner.GetRot(rotation, sourceRot), parent).GetComponent<GrabbableObject>();
				component.fallTime = 0f;
				if (spawnOnNetwork)
				{
					JLogHelper.LogInfo("Spawning item on network.", JLogLevel.Wesley);
					((NetworkBehaviour)component).NetworkObject.Spawn(false);
					OverrideScrapValue(component, overrideValue);
				}
				return component;
			}
			return null;
		}

		public static void OverrideScrapValue(GrabbableObject grabbable, int overrideValue = -1)
		{
			//IL_0033: 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)
			if (overrideValue >= 0)
			{
				JLLNetworkManager.Instance.UpdateScanNodeServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)grabbable).NetworkObject), overrideValue);
			}
			else
			{
				JLLNetworkManager.Instance.UpdateScanNodeServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)grabbable).NetworkObject), Mathf.RoundToInt((float)Random.Range(grabbable.itemProperties.minValue, grabbable.itemProperties.maxValue) * RoundManager.Instance.scrapValueMultiplier));
			}
		}
	}
	public class JActionEvents : NetworkBehaviour, IHittable, IShockableWithGun, INoiseListener
	{
		[Header("Hittable")]
		public bool canBeHit = tru