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 BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
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 LethalConfig;
using LethalConfig.ConfigItems;
using LethalLevelLoader;
using LethalLib.Modules;
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.7.7")]
	[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.7.7";

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

		public static JLL Instance;

		internal ManualLogSource mls;

		internal ManualLogSource wesley;

		public GameObject networkObject;

		public static ConfigEntry<JLogLevel> loggingLevel;

		public static ConfigEntry<bool> purgeWesley;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = Logger.CreateLogSource("JacobG5.JLL");
			wesley = Logger.CreateLogSource("Wesley");
			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();
			};
			purgeWesley = ((BaseUnityPlugin)this).Config.Bind<bool>("Logging", "PurgeWesley", false, "Destroys him.");
			JLogHelper.UpdateLogLevel();
			NetcodePatch(mls, Assembly.GetExecutingAssembly().GetTypes());
			networkObject = NetworkPrefabs.CreateNetworkPrefab("JLL");
			networkObject.AddComponent<JLLNetworkManager>();
			((Object)networkObject).name = "JLL";
			JNetworkPrefabSet.EmptyNetworkObject = NetworkPrefabs.CreateNetworkPrefab("EmptyPrefab");
			JCompatabilityHelper.Init();
			if (JCompatabilityHelper.IsModLoaded.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 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, 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;
		}

		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; }

		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))
					{
						component.AddNetworkPrefab(networkPrefabSet.prefabList[i].prefab);
						num++;
						JLogHelper.LogInfo("Registered Network Object: " + networkPrefabSet.prefabList[i].name + " (" + ((Object)networkPrefabSet.prefabList[i].prefab).name + ")", JLogLevel.Wesley);
					}
				}
			}
			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()
		{
			JIdentifiablePrefab[] array = prefabList;
			IWeightedItem[] weightedItems = prefabList;
			return array[IWeightedItem.GetRandomIndex(weightedItems)].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
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void patchStart(GameNetworkManager __instance)
		{
			((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
	{
		[HarmonyPatch("EquipItem")]
		[HarmonyPrefix]
		public static void patchEquipItem(LungProp __instance)
		{
			if (__instance.isLungDocked)
			{
				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")]
		[HarmonyPrefix]
		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 spawnNetworkManager(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);
			}
		}

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void FindAllEnemyTypes()
		{
			List<EnemyType> enemyTypes = new List<EnemyType>();
			SelectableLevel testAllEnemiesLevel = Object.FindObjectOfType<QuickMenuManager>().testAllEnemiesLevel;
			FindEnemyTypes(testAllEnemiesLevel.Enemies, ref enemyTypes);
			FindEnemyTypes(testAllEnemiesLevel.OutsideEnemies, ref enemyTypes);
			FindEnemyTypes(testAllEnemiesLevel.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;
			}
			JLevelEventTriggers.EventTriggers = new List<JLevelEventTriggers>();
			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.actualClientId == HUDManager.Instance.localPlayer.actualClientId)
			{
				((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;
			}
		}

		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
		}

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

		public Vector3 hitDir = Vector3.zero;

		public EnemySpawner.RotationType hitRotation = EnemySpawner.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 && (Object)(object)DamageTriggerNetworking.DamageTrigger == (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)
			EnemySpawner.RotationType rotationType = hitRotation;
			if (1 == 0)
			{
			}
			Vector3 result = (Vector3)(rotationType switch
			{
				EnemySpawner.RotationType.ObjectRotation => Quaternion.AngleAxis(((Component)this).transform.rotation.y, Vector3.up) * hitDir, 
				EnemySpawner.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((int)player.actualClientId);
				}
				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;

			public float stickTime = 0f;

			private bool stuck = false;

			public bool Update(DamageTrigger trigger)
			{
				if ((Object)(object)player.deadBody != (Object)null)
				{
					if (trigger.corpseType < 0)
					{
						Object.Destroy((Object)(object)((Component)player.deadBody).gameObject);
						player.deadBody = null;
						return false;
					}
					if (!(stickTime > 0f))
					{
						if ((Object)(object)trigger.OverrideCorpseMesh != (Object)null)
						{
							player.deadBody.ChangeMesh(trigger.OverrideCorpseMesh, (Material)null);
						}
						return false;
					}
					if (stuck)
					{
						stickTime -= Time.deltaTime;
					}
					else 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;
					}
					if (stickTime <= 0f)
					{
						JLogHelper.LogInfo("Releasing " + player.playerUsername + "'s corpse");
						player.deadBody.matchPositionExactly = false;
						player.deadBody.attachedTo = null;
						player.deadBody.attachedLimb = null;
						stuck = false;
					}
				}
				else if (Time.realtimeSinceStartup - startTime > 2f)
				{
					JLogHelper.LogInfo("Player Corpse could not be found after two seconds!");
					return false;
				}
				return true;
			}
		}

		public DamageTrigger DamageTrigger;

		public UnityEvent PlayerKilled = new UnityEvent();

		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)
			{
				switch (type)
				{
				case 0:
					if (playerTarget >= 0 && playerTarget < RoundManager.Instance.playersManager.allPlayerScripts.Length && RoundManager.Instance.playersManager.allPlayerScripts[playerTarget].isPlayerDead)
					{
						playerCorpses.Add(new PlayerCorpse
						{
							player = StartOfRound.Instance.allPlayerScripts[playerTarget],
							startTime = Time.realtimeSinceStartup,
							stickTime = DamageTrigger.corpseStickTime
						});
						PlayerKilled.Invoke();
					}
					break;
				case 1:
					EnemyKilled.Invoke();
					break;
				case 2:
					VehicleKilled.Invoke();
					break;
				}
			}
			else
			{
				JLogHelper.LogWarning(((Object)this).name + " DamageTriggerNetworking is missing a linked DamageTrigger!");
			}
		}

		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 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 enum RotationType
		{
			ObjectRotation,
			RandomRotation,
			NoRotation
		}

		[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<SpawnableEnemyWithRarity> randomPool = new List<SpawnableEnemyWithRarity>();

		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 static float GetRot(RotationType rotation, Transform refrence)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (1 == 0)
			{
			}
			float result = rotation switch
			{
				RotationType.ObjectRotation => refrence.rotation.y, 
				RotationType.RandomRotation => Random.Range(0f, 360f), 
				_ => 0f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public void Awake()
		{
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			if (!checkRegistry)
			{
				return;
			}
			if ((Object)(object)type != (Object)null)
			{
				type = JLevelPropertyRegistry.GetRegisteredEnemy(type);
			}
			if (randomPool.Count > 0)
			{
				for (int i = 0; i < randomPool.Count; i++)
				{
					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++)
				{
					SpawnableEnemyWithRarity item = new SpawnableEnemyWithRarity
					{
						enemyType = JLevelPropertyRegistry.AllSortedEnemies[j],
						rarity = 10
					};
					randomPool.Add(item);
				}
			}
			checkRegistry = false;
		}

		public void OnEnable()
		{
			if (spawnOnEnable)
			{
				((MonoBehaviour)this).StartCoroutine(SpawnNextFixedUpdate());
			}
		}

		private IEnumerator SpawnNextFixedUpdate()
		{
			yield return (object)new WaitForFixedUpdate();
			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_0096: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: 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 (!((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)this).transform), 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 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 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.IsModLoaded.LLL)
			{
				LLLHelper.LockExtendedLevel(sceneName, locked);
			}
		}

		public void SetLevelHidden(bool hidden)
		{
			if (JCompatabilityHelper.IsModLoaded.LLL)
			{
				LLLHelper.HideExtendedLevel(sceneName, hidden);
			}
		}

		public void LockLevel(string sceneName)
		{
			if (JCompatabilityHelper.IsModLoaded.LLL)
			{
				LLLHelper.LockExtendedLevel(sceneName, shouldUnlock);
			}
		}

		public void HideLevel(string sceneName)
		{
			if (JCompatabilityHelper.IsModLoaded.LLL)
			{
				LLLHelper.HideExtendedLevel(sceneName, shouldUnlock);
			}
		}

		public void OnTriggerEnter(Collider other)
		{
			if (isTriggerActivated && ((Component)other).CompareTag("Player"))
			{
				SetLevelLocked(!shouldUnlock);
			}
		}
	}
	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((int)player.actualClientId);
		}

		[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];
				if (((NetworkBehaviour)val3).IsOwner)
				{
					val3.DestroyItemInSlotAndSync(val3.currentItemSlot);
				}
				if (runEventOnAllClients || ((NetworkBehaviour)val3).IsOwner)
				{
					((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 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 (!FindRegisteredItem || !((Object)(object)Item != (Object)null))
				{
					return;
				}
				foreach (Item items in RoundManager.Instance.playersManager.allItemsList.itemsList)
				{
					if (Item.itemName == items.itemName)
					{
						Item = items;
						break;
					}
				}
			}
		}

		[Serializable]
		public enum SpawnPoolSource
		{
			CustomList,
			AllItems,
			LevelItems,
			StoreItems
		}

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

		public EnemySpawner.RotationType spawnRotation = EnemySpawner.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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			Item result = null;
			overrideValue = -1;
			offset = Vector3.zero;
			switch (source)
			{
			case SpawnPoolSource.CustomList:
				if (weightedItems != null && weightedItems.Length != 0)
				{
					IWeightedItem[] weightedItems2 = weightedItems;
					WeightedItemRefrence weightedItemRefrence = weightedItems[IWeightedItem.GetRandomIndex(weightedItems2)];
					result = weightedItemRefrence.Item;
					if (weightedItemRefrence.OverrideValue)
					{
						overrideValue = weightedItemRefrence.ScrapValue;
					}
					offset = weightedItemRefrence.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
					});
				}
				IWeightedItem[] weightedItems2 = list.ToArray();
				result = list[IWeightedItem.GetRandomIndex(weightedItems2)].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)
			SpawnRandomItems(SourcePool, ((Component)this).transform.position, RoundManager.Instance.spawnedScrapContainer, 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)
			SpawnRandomItems(SourcePool, pos, RoundManager.Instance.spawnedScrapContainer, CustomList, null, 1, spawnOnNetwork: true, spawnRotation);
		}

		public static List<KeyValuePair<GrabbableObject, int>> SpawnRandomItems(SpawnPoolSource sourcePool, Vector3 position, Transform parent, WeightedItemRefrence[]? customList = null, Vector3[]? offsets = null, int count = 1, bool spawnOnNetwork = true, EnemySpawner.RotationType rotation = EnemySpawner.RotationType.NoRotation)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			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, 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, int overrideValue = -1, bool spawnOnNetwork = true, EnemySpawner.RotationType rotation = EnemySpawner.RotationType.NoRotation)
		{
			//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)
			//IL_0065: 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, Quaternion.Euler(new Vector3(0f, ((Object)(object)parent == (Object)null) ? 0f : EnemySpawner.GetRot(rotation, parent), 0f)), 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 = true;

		public IntEvent OnHit = new IntEvent();

		public InteractEvent OnPlayerHit = new InteractEvent();

		[Header("Shockable")]
		public bool canBeShocked = false;

		public float shockDifficulty = 1f;

		public Vector3 shockPositionOffset = Vector3.zero;

		public InteractEvent OnShock = new InteractEvent();

		public UnityEvent OnStopShocking = new UnityEvent();

		[Header("NoiseListener")]
		public bool isListening = false;

		public float minLoudness = 0.25f;

		public int minTimesInOneSpot = 0;

		public UnityEvent SoundListenedEvent = new UnityEvent();

		public bool Hit(int force, Vector3 hitDirection, PlayerControllerB? playerWhoHit = null, bool playHitSFX = false, int hitID = -1)
		{
			if (!canBeHit)
			{
				return false;
			}
			((UnityEvent<int>)OnHit).Invoke(force);
			if ((Object)(object)playerWhoHit != (Object)null)
			{
				((UnityEvent<PlayerControllerB>)(object)OnPlayerHit).Invoke(playerWhoHit);
			}
			return true;
		}

		public bool CanBeShocked()
		{
			return canBeShocked;
		}

		public float GetDifficultyMultiplier()
		{
			return shockDifficulty;
		}

		public NetworkObject GetNetworkObject()
		{
			return ((NetworkBehaviour)this).NetworkObject;
		}

		public Vector3 GetShockablePosition()
		{
			//IL_0007: 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)
			return ((Component)this).transform.position + shockPositionOffset;
		}

		public Transform GetShockableTransform()
		{
			return ((Component)this).transform;
		}

		public void ShockWithGun(PlayerControllerB shockedByPlayer)
		{
			((UnityEvent<PlayerControllerB>)(object)OnShock).Invoke(shockedByPlayer);
		}

		public void StopShockingWithGun()
		{
			OnStopShocking.Invoke();
		}

		public void DetectNoise(Vector3 noisePosition, float noiseLoudness, int timesPlayedInOneSpot, int noiseID)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (isListening)
			{
				if (Physics.Linecast(((Component)this).transform.position, noisePosition, 256))
				{
					noiseLoudness /= 2f;
				}
				if (!(noiseLoudness < minLoudness) && timesPlayedInOneSpot >= minTimesInOneSpot)
				{
					SoundListenedEvent.Invoke();
				}
			}
		}

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

		protected internal override string __getTypeName()
		{
			return "JActionEvents";
		}
	}
	public class JClientAttatchedObject : MonoBehaviour
	{
		public enum ActiveCondition
		{
			None,
			ActiveOutdoors,
			ActiveIndoors,
			ActiveOutdoorsOutsideShip
		}

		public GameObject target;

		public ActiveCondition enableCondition = ActiveCondition.ActiveOutdoors;

		[Header("Player Attatchment")]
		public bool attachToLocalPlayer = false;

		public bool lerpPosition = false;

		public void Update()
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			switch (enableCondition)
			{
			case ActiveCondition.ActiveOutdoors:
				target.SetActive(!RoundManager.Instance.playersManager.localPlayerController.isInsideFactory);
				break;
			case ActiveCondition.ActiveIndoors:
				target.SetActive(RoundManager.Instance.playersManager.localPlayerController.isInsideFactory);
				break;
			case ActiveCondition.ActiveOutdoorsOutsideShip:
				target.SetActive(!RoundManager.Instance.playersManager.localPlayerController.isInsideFactory && !RoundManager.Instance.playersManager.localPlayerController.isInHangarShipRoom);
				break;
			}
			if (target.activeSelf && attachToLocalPlayer)
			{
				Vector3 position = ((Component)RoundManager.Instance.playersManager.localPlayerController).transform.position;
				if (lerpPosition)
				{
					target.transform.position = Vector3.Lerp(target.transform.position, position, Time.deltaTime);
				}
				else
				{
					target.transform.position = position;
				}
			}
		}
	}
	public class JClientSync : NetworkBehaviour
	{
		[Header("Synced Filter")]
		[SerializeField]
		public JFilter hostFilter;

		public bool runFilterOnStart = false;

		public UnityEvent SyncedFilterSuccess = new UnityEvent();

		public UnityEvent SyncedFilterFailure = new UnityEvent();

		[Header("Host Only")]
		public bool runHostEventOnStart = false;

		public UnityEvent hostEvent = new UnityEvent();

		public InteractEvent hostPlayerEvent = new InteractEvent();

		[Header("Synced")]
		public bool runSyncedEventOnStart = false;

		public UnityEvent syncedEvent = new UnityEvent();

		public InteractEvent syncedPlayerEvent = new InteractEvent();

		private void Start()
		{
			if (!((NetworkBehaviour)this).IsHost && !((NetworkBehaviour)this).IsServer)
			{
				return;
			}
			if ((Object)(object)hostFilter != (Object)null)
			{
				hostFilter.FilteredResult.AddListener((UnityAction<bool>)FilterResultServerRpc);
				if (runFilterOnStart)
				{
					hostFilter.FilterDefault();
				}
			}
			if (runHostEventOnStart)
			{
				TriggerOnHost();
			}
			if (runSyncedEventOnStart)
			{
				TriggerSyncedEvent();
			}
		}

		public void FilterOnHost()
		{
			RunFilterOnHostServerRpc();
		}

		[ServerRpc(RequireOwnership = false)]
		private void RunFilterOnHostServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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_007c: 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(402539773u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 402539773u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					hostFilter?.FilterDefault();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void FilterResultServerRpc(bool success)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_007d: Unknown result type (might be due to invalid IL or missing references)