using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using JLL.API;
using JLL.API.Compatability;
using JLL.API.Events;
using JLL.API.LevelProperties;
using JLL.Components;
using JLL.NetcodePatcher;
using JLL.Patches;
using LethalLevelLoader;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
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.5.2")]
	[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.5.2";

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

		public static JLL Instance;

		internal ManualLogSource mls;

		internal ManualLogSource wesley;

		public GameObject networkObject;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = Logger.CreateLogSource("JacobG5.JLL");
			wesley = Logger.CreateLogSource("Wesley");
			NetcodeRequired(mls);
			networkObject = NetworkPrefabs.CreateNetworkPrefab("JLL");
			networkObject.AddComponent<JLLNetworkManager>();
			((Object)networkObject).name = "JLL";
			JCompatabilityHelper.Init();
			harmony.PatchAll(typeof(ItemChargerPatch));
			harmony.PatchAll(typeof(TimeOfDayPatch));
			harmony.PatchAll(typeof(HudManagerPatch));
			harmony.PatchAll(typeof(StartOfRoundPatch));
			harmony.PatchAll(typeof(RoundManagerPatch));
			harmony.PatchAll(typeof(LungPropPatch));
			harmony.PatchAll(typeof(VehicleControllerPatch));
			harmony.PatchAll(typeof(MenuManagerPatch));
		}

		public static void NetcodeRequired(ManualLogSource logSource)
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				try
				{
					MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
					MethodInfo[] array2 = methods;
					foreach (MethodInfo methodInfo in array2)
					{
						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.Patches
{
	[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))
			{
				JLL.Instance.mls.LogInfo((object)"Found Limiter");
				chargeLimiter.Charge();
			}
		}
	}
	[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()
		{
			JLevelPropertyRegistry.ApplyLevelOverrides();
		}
	}
	[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);
				JLL.Instance.mls.LogInfo((object)"JLL Network Manager Initialized.");
			}
		}

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void FindAllEnemyTypes()
		{
			List<EnemyType> list = new List<EnemyType>();
			SelectableLevel testAllEnemiesLevel = Object.FindObjectOfType<QuickMenuManager>().testAllEnemiesLevel;
			for (int i = 0; i < testAllEnemiesLevel.Enemies.Count; i++)
			{
				if (!list.Contains(testAllEnemiesLevel.Enemies[i].enemyType))
				{
					list.Add(testAllEnemiesLevel.Enemies[i].enemyType);
				}
			}
			for (int j = 0; j < testAllEnemiesLevel.OutsideEnemies.Count; j++)
			{
				if (!list.Contains(testAllEnemiesLevel.OutsideEnemies[j].enemyType))
				{
					list.Add(testAllEnemiesLevel.OutsideEnemies[j].enemyType);
				}
			}
			for (int k = 0; k < testAllEnemiesLevel.DaytimeEnemies.Count; k++)
			{
				if (!list.Contains(testAllEnemiesLevel.DaytimeEnemies[k].enemyType))
				{
					list.Add(testAllEnemiesLevel.DaytimeEnemies[k].enemyType);
				}
			}
			JLevelPropertyRegistry.AllSortedEnemies.AddRange(list);
		}

		[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(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))]
	internal 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 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
	{
		public InteractEvent eventsForClient = new InteractEvent();

		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 UnityEvent<T> hitEvent = new UnityEvent<T>();
		}

		public enum ColliderType
		{
			Player,
			Enemy,
			Vehicle,
			Object
		}

		[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("Continuous Damage")]
		public bool continuousDamage = true;

		public float hitInterval = 0.5f;

		private float timer = 0f;

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

		public DamageTarget<PlayerControllerB> playerTargets = new DamageTarget<PlayerControllerB>();

		public DamageTarget<EnemyAI> enemyTargets = new DamageTarget<EnemyAI>();

		public DamageTarget<VehicleController> vehicleTargets = new DamageTarget<VehicleController>();

		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>();

		public void OnTriggerEnter(Collider collider)
		{
			int num = IdentifyCollider(((Component)collider).gameObject);
			if (num != -1)
			{
				if (damageOnEnter)
				{
					DamageType(((Component)collider).gameObject, num);
				}
				collidersInside.Add(((Component)collider).gameObject, num);
			}
		}

		public void OnTriggerExit(Collider collider)
		{
			if (collidersInside.TryGetValue(((Component)collider).gameObject, out var value))
			{
				if (damageOnExit)
				{
					DamageType(((Component)collider).gameObject, value);
				}
				collidersInside.Remove(((Component)collider).gameObject);
			}
		}

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

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

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

		private void DamageType(GameObject target, int type)
		{
			switch (type)
			{
			default:
				return;
			case 0:
				DamagePlayer(target.GetComponent<PlayerControllerB>());
				break;
			case 1:
				DamageEnemy(target.GetComponent<EnemyAICollisionDetect>().mainScript);
				break;
			case 2:
				DamageVehicle(target.GetComponent<VehicleController>());
				break;
			case 3:
				DamageObject(target.GetComponent<IHittable>());
				break;
			}
			PlayCustomAudio();
		}

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

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

		public void DamagePlayer(PlayerControllerB player)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0044: 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)
			int num = playerTargets.damage;
			if (playerTargets.applyDamageMultiplier)
			{
				num = Mathf.RoundToInt((float)num * damageMultiplier);
			}
			int num2 = num;
			CauseOfDeath val = damageSource;
			Vector3 val2 = hitDir;
			player.DamagePlayer(num2, playNormalDamageSFX, true, val, Mathf.Clamp(corpseType, 0, StartOfRound.Instance.playerRagdolls.Count), false, val2);
			playerTargets.hitEvent.Invoke(player);
		}

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

		public void DamageEnemy(EnemyAI enemy)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			int num = enemyTargets.damage;
			if (enemyTargets.applyDamageMultiplier)
			{
				num = Mathf.RoundToInt((float)num * damageMultiplier);
			}
			enemy.HitEnemyOnLocalClient(num, hitDir, (PlayerControllerB)null, playNormalDamageSFX, -1);
			enemyTargets.hitEvent.Invoke(enemy);
		}

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

		public void DamageVehicle(VehicleController vehicle)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			int num = vehicleTargets.damage;
			if (vehicleTargets.applyDamageMultiplier)
			{
				num = Mathf.RoundToInt((float)num * damageMultiplier);
			}
			VehicleControllerPatch.DealPermanentDamage(vehicle, num, hitDir);
			vehicleTargets.hitEvent.Invoke(vehicle);
		}

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

		public void DamageObject(IHittable obj)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			int num = objectTargets.damage;
			if (objectTargets.applyDamageMultiplier)
			{
				num = Mathf.RoundToInt((float)num * damageMultiplier);
			}
			obj.Hit(num, hitDir, (PlayerControllerB)null, playNormalDamageSFX, -1);
			objectTargets.hitEvent.Invoke(obj);
		}

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

		public float timeScale = 1f;

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

		public void FixedUpdate()
		{
			float num = TimeOfDay.Instance.currentDayTime / TimeOfDay.Instance.totalTime;
			anim.SetFloat("time", num * timeScale);
		}
	}
	public class DelayScript : MonoBehaviour
	{
		public float delaySeconds = 2f;

		public UnityEvent events = new UnityEvent();

		public InteractEvent playerEvents = new InteractEvent();

		public void StartWaiting(PlayerControllerB player)
		{
			((MonoBehaviour)this).StartCoroutine(WaitForDelay(player));
		}

		public void StartWaiting()
		{
			((MonoBehaviour)this).StartCoroutine(WaitForDelay());
		}

		private IEnumerator WaitForDelay(PlayerControllerB? player = null)
		{
			yield return (object)new WaitForSeconds(delaySeconds);
			events.Invoke();
			if ((Object)(object)player != (Object)null)
			{
				((UnityEvent<PlayerControllerB>)(object)playerEvents).Invoke(player);
			}
		}
	}
	public class EnemySpawner : MonoBehaviour
	{
		public EnemyType type;

		[Header("Randomized")]
		public bool spawnRandom = false;

		public SpawnableEnemyWithRarity[] randomPool = (SpawnableEnemyWithRarity[])(object)new SpawnableEnemyWithRarity[0];

		private List<SpawnableEnemyWithRarity> spawnList = new List<SpawnableEnemyWithRarity>();

		[Header("Awake")]
		public bool spawnOnAwake = false;

		public void Start()
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			if ((Object)(object)type != (Object)null)
			{
				type = JLevelPropertyRegistry.GetRegisteredEnemy(type);
			}
			if (randomPool.Length != 0)
			{
				for (int i = 0; i < randomPool.Length; i++)
				{
					SpawnableEnemyWithRarity item = new SpawnableEnemyWithRarity
					{
						enemyType = JLevelPropertyRegistry.GetRegisteredEnemy(randomPool[i].enemyType),
						rarity = randomPool[i].rarity
					};
					spawnList.Add(item);
				}
			}
			else
			{
				for (int j = 0; j < JLevelPropertyRegistry.AllSortedEnemies.Count; j++)
				{
					SpawnableEnemyWithRarity item2 = new SpawnableEnemyWithRarity
					{
						enemyType = JLevelPropertyRegistry.AllSortedEnemies[j],
						rarity = 10
					};
					spawnList.Add(item2);
				}
			}
		}

		public void Awake()
		{
			if (spawnOnAwake)
			{
				SpawnEnemy();
			}
		}

		public void SpawnEnemy()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)RoundManager.Instance).IsHost || ((NetworkBehaviour)RoundManager.Instance).IsServer)
			{
				EnemyType val = (EnemyType)((!spawnRandom) ? ((object)type) : ((object)spawnList[GetWeightedIndex()].enemyType));
				if ((Object)(object)val != (Object)null && (Object)(object)val.enemyPrefab != (Object)null)
				{
					RoundManager.Instance.SpawnEnemyGameObject(((Component)this).transform.position, ((Component)this).transform.rotation.y, 0, val);
				}
			}
		}

		private int GetWeightedIndex()
		{
			int num = 0;
			for (int i = 0; i < spawnList.Count; i++)
			{
				num += spawnList[i].rarity;
			}
			int num2 = Random.Range(0, num);
			for (int j = 0; j < spawnList.Count; j++)
			{
				num2 -= spawnList[j].rarity;
				if (num2 <= 0)
				{
					return j;
				}
			}
			return Random.Range(0, spawnList.Count);
		}
	}
	public class ExtendedLevelLocker : MonoBehaviour
	{
		public SelectableLevel targetLevel;

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

		public bool shouldUnlock = true;

		public void SetLevelLocked(bool locked)
		{
			if (JCompatabilityHelper.IsModLoaded.LLL)
			{
				LLLHelper.LockExtendedLevel(targetLevel, locked);
			}
		}

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

		public void OnTriggerEnter(Collider other)
		{
			if (isTriggerActivated && ((Component)other).CompareTag("Player"))
			{
				SetLevelLocked(!shouldUnlock);
			}
		}
	}
	public class JEventVariables : MonoBehaviour
	{
		[Serializable]
		public class JEventVariable<T>
		{
			public T Variable;

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

			public void Trigger()
			{
				if (Variable != null)
				{
					Event.Invoke(Variable);
				}
			}

			public void Set(T var)
			{
				Variable = var;
			}
		}

		public enum VariableType
		{
			Unknown = -1,
			Number,
			Boolean,
			GameObject,
			Player,
			Enemy
		}

		private int targetIndex = 0;

		[Header("Number Variables (\"number\")")]
		public List<JEventVariable<float>> numberVariables = new List<JEventVariable<float>>();

		[Header("Boolean Variables (\"bool\")")]
		public List<JEventVariable<bool>> booleanVariables = new List<JEventVariable<bool>>();

		[Header("GameObjects")]
		public bool allowDuplicates = true;

		[Header("Player Variables (\"player\")")]
		public List<JEventVariable<PlayerControllerB>> playerVariables = new List<JEventVariable<PlayerControllerB>>();

		public InteractEvent playerEvent = new InteractEvent();

		[Header("Enemy Variables (\"enemy\")")]
		public List<JEventVariable<EnemyAI>> enemyVariables = new List<JEventVariable<EnemyAI>>();

		public EnemyEvent enemyEvent = new EnemyEvent();

		[Header("GameObject Variables (\"object\")")]
		public List<JEventVariable<GameObject>> gameObjectVariables = new List<JEventVariable<GameObject>>();

		public ObjectEvent gameObjectEvent = new ObjectEvent();

		private int GetIndex(VariableType id)
		{
			int count;
			switch (id)
			{
			case VariableType.Number:
				count = numberVariables.Count;
				break;
			case VariableType.Boolean:
				count = booleanVariables.Count;
				break;
			case VariableType.GameObject:
				count = gameObjectVariables.Count;
				break;
			case VariableType.Player:
				count = playerVariables.Count;
				break;
			case VariableType.Enemy:
				count = enemyVariables.Count;
				break;
			default:
				return -1;
			}
			if (count == 0 || targetIndex >= count || targetIndex < 0)
			{
				return -1;
			}
			return targetIndex;
		}

		private VariableType GetType(string identifier)
		{
			string text = identifier.ToLower().Replace("\"", "");
			if (1 == 0)
			{
			}
			VariableType result = text switch
			{
				"number" => VariableType.Number, 
				"bool" => VariableType.Boolean, 
				"object" => VariableType.GameObject, 
				"player" => VariableType.Player, 
				"enemy" => VariableType.Enemy, 
				_ => VariableType.Unknown, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public void TargetIndex(int index)
		{
			targetIndex = index;
		}

		public void Trigger(string varType)
		{
			VariableType type = GetType(varType);
			int index = GetIndex(type);
			if (index >= 0)
			{
				switch (type)
				{
				case VariableType.Number:
					numberVariables[index].Trigger();
					break;
				case VariableType.Boolean:
					booleanVariables[index].Trigger();
					break;
				case VariableType.GameObject:
					gameObjectVariables[index].Trigger();
					break;
				case VariableType.Player:
					playerVariables[index].Trigger();
					break;
				case VariableType.Enemy:
					enemyVariables[index].Trigger();
					break;
				}
			}
		}

		public void TriggerAll(string varType)
		{
			switch (GetType(varType))
			{
			case VariableType.Number:
			{
				for (int j = 0; j < numberVariables.Count; j++)
				{
					numberVariables[j].Trigger();
				}
				break;
			}
			case VariableType.Boolean:
			{
				for (int l = 0; l < booleanVariables.Count; l++)
				{
					booleanVariables[l].Trigger();
				}
				break;
			}
			case VariableType.GameObject:
			{
				for (int m = 0; m < gameObjectVariables.Count; m++)
				{
					gameObjectVariables[m].Trigger();
					if ((Object)(object)gameObjectVariables[m].Variable != (Object)null)
					{
						((UnityEvent<GameObject>)(object)gameObjectEvent).Invoke(gameObjectVariables[m].Variable);
					}
				}
				break;
			}
			case VariableType.Player:
			{
				for (int k = 0; k < playerVariables.Count; k++)
				{
					playerVariables[k].Trigger();
					if ((Object)(object)playerVariables[k].Variable != (Object)null)
					{
						((UnityEvent<PlayerControllerB>)(object)playerEvent).Invoke(playerVariables[k].Variable);
					}
				}
				break;
			}
			case VariableType.Enemy:
			{
				for (int i = 0; i < enemyVariables.Count; i++)
				{
					enemyVariables[i].Trigger();
					if ((Object)(object)enemyVariables[i].Variable != (Object)null)
					{
						((UnityEvent<EnemyAI>)(object)enemyEvent).Invoke(enemyVariables[i].Variable);
					}
				}
				break;
			}
			}
		}

		public void Remove(string varType)
		{
			VariableType type = GetType(varType);
			int index = GetIndex(type);
			if (index >= 0)
			{
				switch (type)
				{
				case VariableType.Number:
					numberVariables.RemoveAt(index);
					break;
				case VariableType.Boolean:
					booleanVariables.RemoveAt(index);
					break;
				case VariableType.GameObject:
					gameObjectVariables.RemoveAt(index);
					break;
				case VariableType.Player:
					playerVariables.RemoveAt(index);
					break;
				case VariableType.Enemy:
					enemyVariables.RemoveAt(index);
					break;
				}
			}
		}

		public void SetNumber(float num)
		{
			int index = GetIndex(VariableType.Number);
			if (index >= 0)
			{
				numberVariables[index].Set(num);
			}
		}

		public void AddNumber(float num)
		{
			int index = GetIndex(VariableType.Number);
			if (index >= 0)
			{
				numberVariables[index].Set(num + numberVariables[index].Variable);
			}
		}

		public void MultiplyNumber(float num)
		{
			int index = GetIndex(VariableType.Number);
			if (index >= 0)
			{
				numberVariables[index].Set(num * numberVariables[index].Variable);
			}
		}

		public void SetBoolean(bool val)
		{
			int index = GetIndex(VariableType.Boolean);
			if (index >= 0)
			{
				booleanVariables[index].Set(val);
			}
		}

		public void AndBool(bool val)
		{
			int index = GetIndex(VariableType.Boolean);
			if (index >= 0)
			{
				booleanVariables[index].Set(val && booleanVariables[index].Variable);
			}
		}

		public void OrBool(bool val)
		{
			int index = GetIndex(VariableType.Boolean);
			if (index >= 0)
			{
				booleanVariables[index].Set(val || booleanVariables[index].Variable);
			}
		}

		public void NotBool(bool val)
		{
			int index = GetIndex(VariableType.Boolean);
			if (index >= 0)
			{
				booleanVariables[index].Set(val != booleanVariables[index].Variable);
			}
		}

		public void SetObject(GameObject obj)
		{
			int index = GetIndex(VariableType.GameObject);
			if (index >= 0)
			{
				gameObjectVariables[index].Set(obj);
			}
		}

		public void AddObject(GameObject obj)
		{
			if (!allowDuplicates)
			{
				for (int i = 0; i < gameObjectVariables.Count; i++)
				{
					if ((Object)(object)gameObjectVariables[i].Variable == (Object)(object)obj)
					{
						return;
					}
				}
			}
			gameObjectVariables.Add(new JEventVariable<GameObject>
			{
				Variable = obj
			});
		}

		public void SetPlayer(PlayerControllerB player)
		{
			int index = GetIndex(VariableType.Player);
			if (index >= 0)
			{
				playerVariables[index].Set(player);
			}
		}

		public void AddPlayer(PlayerControllerB player)
		{
			if (!allowDuplicates)
			{
				for (int i = 0; i < playerVariables.Count; i++)
				{
					if ((Object)(object)playerVariables[i].Variable == (Object)(object)player)
					{
						return;
					}
				}
			}
			playerVariables.Add(new JEventVariable<PlayerControllerB>
			{
				Variable = player
			});
		}

		public void SetEnemy(EnemyAI enemy)
		{
			int index = GetIndex(VariableType.Enemy);
			if (index >= 0)
			{
				enemyVariables[index].Set(enemy);
			}
		}

		public void AddEnemy(EnemyAI enemy)
		{
			if (!allowDuplicates)
			{
				for (int i = 0; i < enemyVariables.Count; i++)
				{
					if ((Object)(object)enemyVariables[i].Variable == (Object)(object)enemy)
					{
						return;
					}
				}
			}
			enemyVariables.Add(new JEventVariable<EnemyAI>
			{
				Variable = enemy
			});
		}
	}
	public class JLevelEventTriggers : MonoBehaviour
	{
		[Serializable]
		public class HourEvent
		{
			public UnityEvent hourEvent = new UnityEvent();

			[Range(0f, 7f)]
			public int hour;
		}

		public static List<JLevelEventTriggers> EventTriggers = new List<JLevelEventTriggers>();

		public UnityEvent ShipLanded = new UnityEvent();

		public UnityEvent LevelLoaded = new UnityEvent();

		public bool onlyOnFirstApparatus = false;

		private bool apparatusWasPulled = false;

		public UnityEvent ApparatusPulled = new UnityEvent();

		public HourEvent[] hourlyEvents = new HourEvent[0];

		private int prevHour = 0;

		public void Start()
		{
			EventTriggers.Add(this);
			LevelLoaded.Invoke();
		}

		public void FixedUpdate()
		{
			if (hourlyEvents.Length == 0)
			{
				return;
			}
			int hour = TimeOfDay.Instance.hour;
			if (prevHour != hour)
			{
				for (int i = 0; i < hourlyEvents.Length; i++)
				{
					if (hourlyEvents[i].hour == hour)
					{
						hourlyEvents[i].hourEvent.Invoke();
					}
				}
			}
			prevHour = hour;
		}

		public void InvokeApparatus()
		{
			if (!onlyOnFirstApparatus || !apparatusWasPulled)
			{
				ApparatusPulled.Invoke();
				apparatusWasPulled = true;
			}
		}
	}
	public class JMaterialReplacer : MonoBehaviour
	{
		[Serializable]
		public class MaterialReplacement
		{
			public Material original;

			public Material replacement;
		}

		public MaterialReplacement[] replacements;

		public bool searchChildren = true;

		public bool triggerPostDunGen = false;

		public void SearchAndReplace()
		{
			SearchAndReplace(((Component)this).transform);
		}

		private void SearchAndReplace(Transform target)
		{
			Renderer val = default(Renderer);
			if (((Component)target).TryGetComponent<Renderer>(ref val))
			{
				int num = 0;
				for (int i = 0; i < replacements.Length; i++)
				{
					Material[] materials = val.materials;
					for (int j = 0; j < materials.Length; j++)
					{
						if (((Object)materials[j]).name.Equals(((Object)replacements[i].original).name + " (Instance)"))
						{
							materials[j] = replacements[i].replacement;
							num++;
						}
					}
					((Component)target).GetComponent<Renderer>().materials = materials;
				}
			}
			if (searchChildren)
			{
				for (int k = 0; k < ((Component)target).transform.childCount; k++)
				{
					SearchAndReplace(((Component)target).transform.GetChild(k));
				}
			}
		}
	}
	public class JMessageLogger : MonoBehaviour
	{
		public string logName = "";

		public void LogMessage(string message)
		{
			string text = "";
			if (StartOfRound.Instance.shipHasLanded)
			{
				text = RoundManager.Instance.currentLevel.PlanetName ?? "";
			}
			JLL.Instance.mls.LogMessage((object)("(" + text + ")<" + logName + ">: " + message));
		}

		public void SendTip(string message)
		{
			JHudHelper.QueueDisplayTip(logName, message);
		}

		public void SendWarningTip(string message)
		{
			JHudHelper.QueueDisplayTip(logName, message, isWarning: true);
		}

		public void SendChatMessage(string message)
		{
			HUDManager.Instance.AddTextToChatOnServer(message, -1);
		}
	}
	public class JWaterFilter : MonoBehaviour
	{
		public Volume underwaterFilter;

		[Header("Audio")]
		public bool playBreathingSounds = true;

		public AudioSource customUnderwaterSounds;

		public bool enableUnderwaterLowPassFilter = true;

		public float underwaterLowPassCutoff = 700f;

		public void Start()
		{
			underwaterFilter.weight = 0f;
		}

		public void UnderwaterFilters(HUDManager manager, bool isSpectating)
		{
			((Behaviour)manager.audioListenerLowPass).enabled = enableUnderwaterLowPassFilter;
			manager.audioListenerLowPass.cutoffFrequency = Mathf.Lerp(manager.audioListenerLowPass.cutoffFrequency, underwaterLowPassCutoff, 10f * Time.deltaTime);
			underwaterFilter.weight = 1f;
			if (playBreathingSounds && !isSpectating && !manager.breathingUnderwaterAudio.isPlaying)
			{
				manager.breathingUnderwaterAudio.Play();
			}
			if (!isSpectating && (Object)(object)customUnderwaterSounds != (Object)null && !customUnderwaterSounds.isPlaying)
			{
				customUnderwaterSounds.Play();
			}
		}
	}
	public class JWeatherObject : MonoBehaviour
	{
		public bool isWhitelist = true;

		public LevelWeatherType[] AllowedWeathers = (LevelWeatherType[])(object)new LevelWeatherType[0];

		[Header("Targets ")]
		public bool defaultToSelf = true;

		public GameObject activeObject;

		public GameObject inverseObject;

		[Header("Event Triggers")]
		public UnityEvent onActivate = new UnityEvent();

		public UnityEvent onDeactivate = new UnityEvent();

		[Header("Weather IDs (For Modded Weathers)")]
		public string[] WeatherStrings = new string[0];

		public void Start()
		{
			if (defaultToSelf && (Object)(object)activeObject == (Object)null)
			{
				activeObject = ((Component)this).gameObject;
			}
			ToggleObjects();
		}

		public void ToggleObjects()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			bool flag = (AllowedWeathers.Contains(RoundManager.Instance.currentLevel.currentWeather) || CheckWeatherStrings()) == isWhitelist;
			GameObject obj = activeObject;
			if (obj != null)
			{
				obj.SetActive(flag);
			}
			GameObject obj2 = inverseObject;
			if (obj2 != null)
			{
				obj2.SetActive(!flag);
			}
			if (flag)
			{
				onActivate.Invoke();
			}
			else
			{
				onDeactivate.Invoke();
			}
		}

		private bool CheckWeatherStrings()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected I4, but got Unknown
			int num = (int)RoundManager.Instance.currentLevel.currentWeather;
			string text = "";
			if (num > 0)
			{
				WeatherEffect val = TimeOfDay.Instance.effects[num];
				text = val.name;
			}
			bool flag = false;
			if (text != "")
			{
				flag = WeatherStrings.Contains(text);
			}
			if (!flag && JCompatabilityHelper.IsModLoaded.WeatherRegistry)
			{
				WeatherStrings.Contains(JWeatherRegistryHelper.GetCurrentWeatherName());
			}
			return flag;
		}
	}
	public class JWeatherOverride : MonoBehaviour
	{
		public static JWeatherOverride? Instance;

		[Header("Overrides")]
		public WeatherEffect[] overrideEffects = (WeatherEffect[])(object)new WeatherEffect[0];

		[Header("Foggy Weather")]
		public LocalVolumetricFog[] foggyWeatherVolumes = (LocalVolumetricFog[])(object)new LocalVolumetricFog[0];

		public Volume[] foggyVolumes = (Volume[])(object)new Volume[0];

		[Header("Debug")]
		public float overrideDelay = 4f;

		public void Start()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			JLL.Instance.mls.LogInfo((object)"Weather Override Start");
			Random random = new Random(StartOfRound.Instance.randomMapSeed + 101);
			WeatherEffect[] array = overrideEffects;
			foreach (WeatherEffect val in array)
			{
				val.effectEnabled = false;
				if ((Object)(object)val.effectPermanentObject != (Object)null)
				{
					val.effectPermanentObject.SetActive(false);
				}
			}
			if ((int)TimeOfDay.Instance.currentLevelWeather == 3)
			{
				float num = random.Next((int)TimeOfDay.Instance.currentWeatherVariable, (int)TimeOfDay.Instance.currentWeatherVariable2);
				LocalVolumetricFog[] array2 = foggyWeatherVolumes;
				foreach (LocalVolumetricFog val2 in array2)
				{
					val2.parameters.meanFreePath = num;
				}
				Volume[] array3 = foggyVolumes;
				Fog val4 = default(Fog);
				foreach (Volume val3 in array3)
				{
					VolumeProfile profile = val3.profile;
					if (profile.TryGet<Fog>(ref val4))
					{
						((VolumeParameter<float>)(object)val4.meanFreePath).value = num;
					}
				}
			}
			((MonoBehaviour)this).StartCoroutine(OverrideWeather());
		}

		public WeatherEffect? getOverrideEffect(string original)
		{
			WeatherEffect[] array = overrideEffects;
			foreach (WeatherEffect val in array)
			{
				if (original.Equals(val.name))
				{
					return val;
				}
			}
			return null;
		}

		private IEnumerator OverrideWeather()
		{
			yield return (object)new WaitForSeconds(overrideDelay);
			OverrideWeatherObjects();
			Instance = this;
		}

		private void OverrideWeatherObjects()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (JCompatabilityHelper.IsModLoaded.WeatherRegistry)
			{
				JWeatherRegistryHelper.OverrideWeatherObjects(this);
			}
			if ((int)StartOfRound.Instance.currentLevel.currentWeather == -1)
			{
				return;
			}
			WeatherEffect val = TimeOfDay.Instance.effects[StartOfRound.Instance.currentLevel.currentWeather];
			WeatherEffect overrideEffect = getOverrideEffect(val.name);
			if (overrideEffect == null)
			{
				return;
			}
			val.effectEnabled = false;
			overrideEffect.effectEnabled = true;
			if ((Object)(object)overrideEffect.effectPermanentObject != (Object)null)
			{
				if ((Object)(object)val.effectPermanentObject != (Object)null)
				{
					val.effectPermanentObject.SetActive(false);
				}
				overrideEffect.effectPermanentObject.SetActive(true);
			}
			if (!StartOfRound.Instance.currentLevel.overrideWeather)
			{
				val.effectEnabled = false;
				overrideEffect.effectEnabled = true;
			}
		}

		public void Update()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: 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)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			CheckWeatherEffectChanges();
			Vector3 val = ((!GameNetworkManager.Instance.localPlayerController.isPlayerDead) ? ((Component)StartOfRound.Instance.localPlayerController).transform.position : ((Component)StartOfRound.Instance.spectateCamera).transform.position);
			for (int i = 0; i < overrideEffects.Length; i++)
			{
				if (overrideEffects[i].effectEnabled)
				{
					if (!string.IsNullOrEmpty(overrideEffects[i].sunAnimatorBool) && (Object)(object)TimeOfDay.Instance.sunAnimator != (Object)null)
					{
						TimeOfDay.Instance.sunAnimator.SetBool(overrideEffects[i].sunAnimatorBool, true);
					}
					overrideEffects[i].transitioning = false;
					if ((Object)(object)overrideEffects[i].effectObject != (Object)null)
					{
						overrideEffects[i].effectObject.SetActive(true);
						if (overrideEffects[i].lerpPosition)
						{
							overrideEffects[i].effectObject.transform.position = Vector3.Lerp(overrideEffects[i].effectObject.transform.position, val, Time.deltaTime);
						}
						else
						{
							overrideEffects[i].effectObject.transform.position = val;
						}
					}
				}
				else if (!overrideEffects[i].transitioning)
				{
					overrideEffects[i].transitioning = true;
					if (overrideEffects[i].lerpPosition)
					{
						((MonoBehaviour)this).StartCoroutine(TimeOfDayPatch.fadeOutEffect(TimeOfDay.Instance, overrideEffects[i], val));
					}
					else
					{
						TimeOfDayPatch.DisableWeatherEffect(TimeOfDay.Instance, overrideEffects[i]);
					}
				}
			}
		}

		private void CheckWeatherEffectChanges()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (JCompatabilityHelper.IsModLoaded.WeatherRegistry)
			{
				JWeatherRegistryHelper.CheckWeatherChanges(this);
			}
			if ((int)StartOfRound.Instance.currentLevel.currentWeather == -1)
			{
				return;
			}
			WeatherEffect val = TimeOfDay.Instance.effects[StartOfRound.Instance.currentLevel.currentWeather];
			WeatherEffect overrideEffect = getOverrideEffect(val.name);
			if (overrideEffect != null)
			{
				if (val.effectEnabled)
				{
					val.effectEnabled = false;
					overrideEffect.effectEnabled = true;
				}
				if ((Object)(object)val.effectPermanentObject != (Object)null && (Object)(object)overrideEffect.effectPermanentObject != (Object)null && val.effectPermanentObject.activeSelf)
				{
					val.effectPermanentObject.SetActive(false);
					overrideEffect.effectPermanentObject.SetActive(true);
				}
			}
		}
	}
	public class MagicWesley : MonoBehaviour
	{
		public string favoriteQuote = "";

		public bool inRubberRoom = false;

		public bool withRats = true;

		public void Start()
		{
			if (!inRubberRoom && favoriteQuote != "")
			{
				JLL.Instance.wesley.LogInfo((object)favoriteQuote);
			}
			if (withRats && Random.Range(0f, 10f) < 1.5f)
			{
				JLL.Instance.wesley.LogInfo((object)"This is why I haven't updated my moons...");
			}
		}

		public void UpdateYourMoons()
		{
			JLL.Instance.wesley.LogInfo((object)"soon tm");
		}

		public void PleaseSay(string txt)
		{
			if (Random.Range(0f, 10f) < 1f)
			{
				JLL.Instance.wesley.LogInfo((object)"No");
			}
			else
			{
				JLL.Instance.wesley.LogInfo((object)txt);
			}
		}
	}
	public class RandomizedEvent : NetworkBehaviour
	{
		[Serializable]
		public class WeightedEvent
		{
			public UnityEvent Event = new UnityEvent();

			public InteractEvent PlayerEvent = new InteractEvent();

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

		public bool triggerOnAwake = false;

		public WeightedEvent[] weightedEvents = new WeightedEvent[0];

		public InteractEvent RandomPlayerEvent = new InteractEvent();

		public void Awake()
		{
			if (triggerOnAwake)
			{
				RollEvent();
			}
		}

		public void RollEvent()
		{
			RollRandomServerRpc(-1);
		}

		public void RollPlayerEvent(PlayerControllerB player)
		{
			RollRandomServerRpc((int)player.actualClientId);
		}

		[ServerRpc(RequireOwnership = false)]
		private void RollRandomServerRpc(int playerId)
		{
			//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(862362801u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerId);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 862362801u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && weightedEvents.Length != 0)
				{
					int weightedIndex = GetWeightedIndex();
					JLL.Instance.mls.LogInfo((object)$"Server Generated: {weightedIndex}");
					RollResultClientRpc(weightedIndex, playerId);
				}
			}
		}

		private int GetWeightedIndex()
		{
			int num = 0;
			for (int i = 0; i < weightedEvents.Length; i++)
			{
				num += weightedEvents[i].Weight;
			}
			int num2 = Random.Range(0, num);
			for (int j = 0; j < weightedEvents.Length; j++)
			{
				num2 -= weightedEvents[j].Weight;
				if (num2 <= 0)
				{
					return j;
				}
			}
			return Random.Range(0, weightedEvents.Length);
		}

		[ClientRpc]
		private void RollResultClientRpc(int value, int playerId)
		{
			//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(2905441623u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, value);
				BytePacker.WriteValueBitPacked(val2, playerId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2905441623u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				JLL.Instance.mls.LogInfo((object)$"Client Received: {value}");
				weightedEvents[value].Event.Invoke();
				if (playerId != -1)
				{
					((UnityEvent<PlayerControllerB>)(object)weightedEvents[value].PlayerEvent).Invoke(RoundManager.Instance.playersManager.allPlayerScripts[playerId]);
				}
			}
		}

		public void StartRandomPlayerEvent()
		{
			RandomPlayerEventServerRpc();
		}

		[ServerRpc(RequireOwnership = false)]
		private void RandomPlayerEventServerRpc()
		{
			//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(2647303802u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2647303802u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					RandomPlayerEventClientRpc(Random.Range(0, RoundManager.Instance.playersManager.allPlayerScripts.Length));
				}
			}
		}

		[ClientRpc]
		private void RandomPlayerEventClientRpc(int playerId)
		{
			//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 != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4072368991u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerId);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4072368991u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					((UnityEvent<PlayerControllerB>)(object)RandomPlayerEvent).Invoke(RoundManager.Instance.playersManager.allPlayerScripts[Math.Clamp(playerId, 0, RoundManager.Instance.playersManager.allPlayerScripts.Length - 1)]);
				}
			}
		}

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

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_RandomizedEvent()
		{
			//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
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(862362801u, new RpcReceiveHandler(__rpc_handler_862362801));
			NetworkManager.__rpc_func_table.Add(2905441623u, new RpcReceiveHandler(__rpc_handler_2905441623));
			NetworkManager.__rpc_func_table.Add(2647303802u, new RpcReceiveHandler(__rpc_handler_2647303802));
			NetworkManager.__rpc_func_table.Add(4072368991u, new RpcReceiveHandler(__rpc_handler_4072368991));
		}

		private static void __rpc_handler_862362801(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 playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((RandomizedEvent)(object)target).RollRandomServerRpc(playerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2905441623(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 value = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref value);
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((RandomizedEvent)(object)target).RollResultClientRpc(value, playerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2647303802(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((RandomizedEvent)(object)target).RandomPlayerEventServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4072368991(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 playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((RandomizedEvent)(object)target).RandomPlayerEventClientRpc(playerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "RandomizedEvent";
		}
	}
	public class SeatController : NetworkBehaviour
	{
		public InteractTrigger seatTrigger;

		public InteractTrigger exitTrigger;

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

		public bool disableExitTrigger = true;

		public AudioClip sitDown;

		[HideInInspector]
		public PlayerControllerB? currentPassenger;

		[HideInInspector]
		public bool localPlayerInSeat = false;

		private readonly int exitLayerMask = 2305;

		public void Start()
		{
			((Component)exitTrigger).gameObject.SetActive(!disableExitTrigger);
		}

		[ServerRpc(RequireOwnership = false)]
		private void LeaveSeatServerRpc(int playerId, Vector3 exitPoint)
		{
			//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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			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(947975618u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerId);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref exitPoint);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 947975618u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					LeaveSeatClientRpc(playerId, exitPoint);
				}
			}
		}

		[ClientRpc]
		private void LeaveSeatClientRpc(int playerId, Vector3 exitPoint)
		{
			//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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			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(420214053u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerId);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref exitPoint);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 420214053u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[playerId];
			if (!((Object)(object)val3 == (Object)(object)GameNetworkManager.Instance.localPlayerController))
			{
				val3.TeleportPlayer(exitPoint, false, 0f, false, true);
				currentPassenger = null;
				if (!((NetworkBehaviour)this).IsOwner)
				{
					SetVehicleCollisionForPlayer(setEnabled: true, GameNetworkManager.Instance.localPlayerController);
				}
				seatTrigger.interactable = true;
			}
		}

		public void SetPlayerInSeat(PlayerControllerB player)
		{
			if ((Object)(object)sitDown != (Object)null)
			{
				player.movementAudio.PlayOneShot(sitDown);
			}
			if ((Object)(object)player == (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				localPlayerInSeat = true;
				if (disableExitTrigger)
				{
					((Component)exitTrigger).gameObject.SetActive(true);
				}
			}
			else
			{
				seatTrigger.interactable = false;
			}
			currentPassenger = player;
		}

		private int GetExitPos()
		{
			//IL_001a: 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)
			for (int i = 0; i < exitPoints.Length; i++)
			{
				if (!Physics.Linecast(((Component)GameNetworkManager.Instance.localPlayerController.gameplayCamera).transform.position, exitPoints[i].position, exitLayerMask, (QueryTriggerInteraction)1))
				{
					return i;
				}
			}
			return -1;
		}

		public void OnCancelAnim()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			seatTrigger.interactable = true;
			localPlayerInSeat = false;
			currentPassenger = null;
			SetVehicleCollisionForPlayer(setEnabled: true, GameNetworkManager.Instance.localPlayerController);
			LeaveSeatServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId, ((Component)GameNetworkManager.Instance.localPlayerController).transform.position);
		}

		public void ExitSeat()
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if (localPlayerInSeat)
			{
				if (disableExitTrigger)
				{
					((Component)exitTrigger).gameObject.SetActive(false);
				}
				int exitPos = GetExitPos();
				if (exitPos != -1)
				{
					GameNetworkManager.Instance.localPlayerController.TeleportPlayer(exitPoints[exitPos].position, false, 0f, false, true);
				}
				else
				{
					GameNetworkManager.Instance.localPlayerController.TeleportPlayer(((Component)this).transform.position + Vector3.up, false, 0f, false, true);
				}
			}
		}

		public void SetVehicleCollisionForPlayer(bool setEnabled, PlayerControllerB player)
		{
			//IL_0028: 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)
			if (setEnabled)
			{
				((Collider)((Component)player).GetComponent<CharacterController>()).excludeLayers = LayerMask.op_Implicit(0);
			}
			else
			{
				((Collider)((Component)player).GetComponent<CharacterController>()).excludeLayers = LayerMask.op_Implicit(1073741824);
			}
		}

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

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_SeatController()
		{
			//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(947975618u, new RpcReceiveHandler(__rpc_handler_947975618));
			NetworkManager.__rpc_func_table.Add(420214053u, new RpcReceiveHandler(__rpc_handler_420214053));
		}

		private static void __rpc_handler_947975618(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0052: 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 playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				Vector3 exitPoint = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref exitPoint);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((SeatController)(object)target).LeaveSeatServerRpc(playerId, exitPoint);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_420214053(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0052: 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 playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				Vector3 exitPoint = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref exitPoint);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((SeatController)(object)target).LeaveSeatClientRpc(playerId, exitPoint);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "SeatController";
		}
	}
	public class TelePoint : MonoBehaviour
	{
		public bool rotatePlayer = false;

		public void TeleportPlayer(PlayerControllerB player)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			player.TeleportPlayer(((Component)this).transform.position, rotatePlayer, ((Component)this).transform.rotation.y, false, true);
		}

		public void Teleport(GameObject obj)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			obj.transform.position = ((Component)this).transform.position;
		}
	}
	public class TerrainObstacle : MonoBehaviour
	{
		public int health = 5;

		public float damageThreshold = 5f;

		[Header("FX")]
		public GameObject breakFX;

		private GameObject? oldBreakFX;

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

		[Header("Collision Types")]
		public bool detectTriggers = true;

		public bool detectColliders = true;

		public void OnTriggerEnter(Collider other)
		{
			if (detectTriggers)
			{
				CalcCollision(other);
			}
		}

		public void OnCollisionEnter(Collision collision)
		{
			if (detectColliders)
			{
				CalcCollision(collision.collider);
			}
		}

		public void CalcCollision(Collider detected)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_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)
			VehicleController val = default(VehicleController);
			if (((Component)detected).TryGetComponent<VehicleController>(ref val))
			{
				float magnitude = ((Vector3)(ref val.averageVelocity)).magnitude;
				if (!((Object)(object)val == (Object)null) && ((NetworkBehaviour)val).IsOwner && magnitude > damageThreshold && Vector3.Angle(val.averageVelocity, ((Component)this).transform.position - val.mainRigidbody.position) < 80f)
				{
					JLLNetworkManager.Instance.DestroyTerrainObstacleOnLocalClient(((Component)this).transform.position, Mathf.RoundToInt(magnitude));
					val.CarReactToObstacle(val.mainRigidbody.position - ((Component)this).transform.position, ((Component)this).transform.position, Vector3.zero, (CarObstacleType)2, 1f, (EnemyAI)null, true);
				}
			}
		}

		public void Damage(int ammount)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			health -= ammount;
			if ((Object)(object)breakFX != (Object)null)
			{
				if ((Object)(object)oldBreakFX != (Object)null)
				{
					Object.Destroy((Object)(object)oldBreakFX);
				}
				AudioSource val = default(AudioSource);
				if ((oldBreakFX = Object.Instantiate<GameObject>(breakFX, ((Component)this).gameObject.transform.position + Vector3.up, Quaternion.identity)).TryGetComponent<AudioSource>(ref val))
				{
					if (clips.Length != 0)
					{
						val.clip = clips[Random.Range(0, clips.Length - 1)];
					}
					val.Play();
				}
			}
			if (health <= 0)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}
	public class TriggerEnterEvent : MonoBehaviour
	{
		public UnityEvent onAwake = new UnityEvent();

		[Header("OnTriggerEnter")]
		public ObjectEvent anythingEntered = new ObjectEvent();

		[Space(15f)]
		public InteractEvent playerEntered = new InteractEvent();

		public EnemyEvent enemyEntered = new EnemyEvent();

		public VehicleEvent vehicleEntered = new VehicleEvent();

		public DamageableEvent hittableEntered = new DamageableEvent();

		public ObjectEvent unknownEntered = new ObjectEvent();

		public void Awake()
		{
			onAwake.Invoke();
		}

		public void OnTriggerEnter(Collider other)
		{
			((UnityEvent<GameObject>)(object)anythingEntered).Invoke(((Component)other).gameObject);
			InvokeType(((Component)other).gameObject, DamageTrigger.IdentifyCollider(((Component)other).gameObject));
		}

		private void InvokeType(GameObject target, int type)
		{
			switch (type)
			{
			case 0:
				((UnityEvent<PlayerControllerB>)(object)playerEntered).Invoke(target.GetComponent<PlayerControllerB>());
				break;
			case 1:
				((UnityEvent<EnemyAI>)(object)enemyEntered).Invoke(target.GetComponent<EnemyAICollisionDetect>().mainScript);
				break;
			case 2:
				((UnityEvent<VehicleController>)(object)vehicleEntered).Invoke(target.GetComponent<VehicleController>());
				break;
			case 3:
				((UnityEvent<IHittable>)(object)hittableEntered).Invoke(target.GetComponent<IHittable>());
				break;
			default:
				((UnityEvent<GameObject>)(object)unknownEntered).Invoke(target);
				break;
			}
		}
	}
}
namespace JLL.Components.Filters
{
	public class EnemyFilter : JFilter<EnemyAI>
	{
		[Header("EnemyType")]
		public NameFilter enemyType = new NameFilter();

		public CheckFilter isInvulnerable = new CheckFilter();

		[Header("Enemy Stats")]
		public NumericFilter healthCheck = new NumericFilter
		{
			value = 2f
		};

		public override void Filter(EnemyAI enemy)
		{
			bool flag = true;
			if (enemyType.shouldCheck)
			{
				flag &= enemyType.CheckValue(enemy.enemyType.enemyName);
			}
			if (isInvulnerable.shouldCheck)
			{
				flag &= isInvulnerable.CheckValue(!enemy.enemyType.canDie);
			}
			if (healthCheck.shouldCheck)
			{
				flag &= healthCheck.CheckValue(enemy.enemyHP);
			}
			Result(flag, enemy);
		}
	}
	public abstract class JFilter<T> : MonoBehaviour
	{
		[Header("JFilter")]
		public UnityEvent<T> filteredEvent = new UnityEvent<T>();

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

		public abstract void Filter(T input);

		public void Result(bool success, T input)
		{
			if (success)
			{
				filteredEvent.Invoke(input);
			}
			else
			{
				failedEvent.Invoke(input);
			}
		}
	}
	[Serializable]
	public abstract class JFilterProperty<T>
	{
		public bool shouldCheck = false;

		public T value;

		public abstract bool CheckValue(T val);
	}
	[Serializable]
	public class NumericFilter : JFilterProperty<float>
	{
		public enum FilterOpperand
		{
			GreaterThan,
			LessThan,
			EqualTo
		}

		public FilterOpperand operation = FilterOpperand.EqualTo;

		public override bool CheckValue(float val)
		{
			return operation switch
			{
				FilterOpperand.EqualTo => val == value, 
				FilterOpperand.GreaterThan => val > value, 
				FilterOpperand.LessThan => val < value, 
				_ => false, 
			};
		}
	}
	[Serializable]
	public class NameFilter : JFilterProperty<string>
	{
		public override bool CheckValue(string val)
		{
			return val.ToLower() == value.ToLower();
		}
	}
	[Serializable]
	public class CheckFilter : JFilterProperty<bool>
	{
		public override bool CheckValue(bool val)
		{
			return val == value;
		}
	}
	public class PlayerFilter : JFilter<PlayerControllerB>
	{
		[Serializable]
		public class HeldItemFilter
		{
			public bool shouldCheck = false;

			public NameFilter itemName = new NameFilter();

			public NumericFilter itemCharge = new NumericFilter
			{
				value = 100f
			};

			public bool CheckValue(PlayerControllerB player)
			{
				if (shouldCheck && (Object)(object)player.currentlyHeldObject != (Object)null)
				{
					GrabbableObject currentlyHeldObject = player.currentlyHeldObject;
					bool flag = true;
					if (itemName.shouldCheck)
					{
						flag &= itemName.CheckValue(currentlyHeldObject.itemProperties.itemName);
					}
					if (itemCharge.shouldCheck && currentlyHeldObject.insertedBattery != null)
					{
						flag &= itemCharge.CheckValue(currentlyHeldObject.insertedBattery.charge);
					}
					return flag;
				}
				return false;
			}
		}

		[Header("Inventory")]
		public HeldItemFilter heldItem = new HeldItemFilter();

		public string[] inventoryContents = new string[0];

		[Header("Player Stats")]
		public NumericFilter healthCheck = new NumericFilter
		{
			value = 20f
		};

		public NumericFilter staminaCheck = new NumericFilter
		{
			value = 20f
		};

		public NumericFilter weightCheck = new NumericFilter
		{
			value = 2f
		};

		public override void Filter(PlayerControllerB player)
		{
			bool flag = true;
			if (heldItem.shouldCheck)
			{
				flag &= heldItem.CheckValue(player);
			}
			if (inventoryContents.Length != 0)
			{
				int num = 0;
				for (int i = 0; i < inventoryContents.Length; i++)
				{
					for (int j = 0; j < player.ItemSlots.Length; j++)
					{
						if (!((Object)(object)player.ItemSlots[j] == (Object)null) && player.ItemSlots[j].itemProperties.itemName.ToLower().Equals(inventoryContents[i].ToLower()))
						{
							num++;
							break;
						}
					}
				}
				flag &= num == inventoryContents.Length;
			}
			if (healthCheck.shouldCheck)
			{
				flag &= healthCheck.CheckValue(player.health);
			}
			if (staminaCheck.shouldCheck)
			{
				flag &= staminaCheck.CheckValue(player.sprintMeter);
			}
			if (weightCheck.shouldCheck)
			{
				flag &= weightCheck.CheckValue(player.carryWeight);
			}
			Result(flag, player);
		}
	}
}
namespace JLL.API
{
	public class JCompatabilityHelper
	{
		public class ModCompatCheck
		{
			public bool WeatherRegistry = false;

			public bool SimpleCommands = false;

			public bool LLL = false;

			public bool ReservedSlotCore = false;
		}

		public static ModCompatCheck IsModLoaded = new ModCompatCheck();

		internal static void Init()
		{
			using Dictionary<string, PluginInfo>.Enumerator enumerator = Chainloader.PluginInfos.GetEnumerator();
			while (enumerator.MoveNext())
			{
				switch (enumerator.Current.Key)
				{
				case "mrov.WeatherRegistry":
					IsModLoaded.WeatherRegistry = true;
					break;
				case "JacobG5.SimpleCommands":
					IsModLoaded.SimpleCommands = true;
					break;
				case "imabatby.lethallevelloader":
					IsModLoaded.LLL = true;
					break;
				case "FlipMods.ReservedItemSlotCore":
					IsModLoaded.ReservedSlotCore = true;
					break;
				}
			}
		}
	}
	public class JHudHelper
	{
		private class DisplayTip
		{
			public string headerText;

			public string bodyText;

			public bool isWarning;

			public bool useSave;

			public string prefsKey;

			public DisplayTip(string headerText, string bodyText, bool isWarning, bool useSave, string prefsKey)
			{
				this.headerText = headerText;
				this.bodyText = bodyText;
				this.isWarning = isWarning;
				this.useSave = useSave;
				this.prefsKey = prefsKey;
			}
		}

		internal static bool isTipActive = false;

		private static List<DisplayTip> displayTipQueue = new List<DisplayTip>();

		public static void QueueDisplayTip(string headerText, string bodyText, bool isWarning = false, bool useSave = false, string prefsKey = "LC_Tip1")
		{
			displayTipQueue.Add(new DisplayTip(headerText, bodyText, isWarning, useSave, prefsKey));
			DisplayNextTip();
		}

		public static void ClearDisplayTipQueue()
		{
			displayTipQueue = new List<DisplayTip>();
		}

		internal static bool DisplayNextTip()
		{
			if (isTipActive)
			{
				return false;
			}
			if (displayTipQueue.Count > 0)
			{
				DisplayTip displayTip = displayTipQueue[0];
				displayTipQueue.RemoveAt(0);
				HUDManager.Instance.DisplayTip(displayTip.headerText, displayTip.bodyText, displayTip.isWarning, displayTip.useSave, displayTip.prefsKey);
				return true;
			}
			return false;
		}
	}
	public class JLLNetworkManager : NetworkBehaviour
	{
		public static JLLNetworkManager Instance;

		public Collider[] tempColliderResults = (Collider[])(object)new Collider[20];

		public void Awake()
		{
			Instance = this;
		}

		public void DestroyTerrainObstacleOnLocalClient(Vector3 pos, int damage)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (DestroyTerrainObstacleAtPosition(pos, damage))
			{
				BreakTerrainObstacleServerRpc(pos, damage, (int)GameNetworkManager.Instance.localPlayerController.playerClientId);
			}
		}

		private bool DestroyTerrainObstacleAtPosition(Vector3 pos, int damage)
		{
			//IL_0001: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			int num = Physics.OverlapSphereNonAlloc(pos, 5f, tempColliderResults, 33554432, (QueryTriggerInteraction)1);
			if (num == 0)
			{
				return false;
			}
			bool flag = false;
			TerrainObstacle terrainObstacle = default(TerrainObstacle);
			for (int i = 0; i < num; i++)
			{
				if (((Component)tempColliderResults[i]).TryGetComponent<TerrainObstacle>(ref terrainObstacle))
				{
					terrainObstacle.Damage(damage);
					flag = true;
				}
			}
			if (flag)
			{
				float num2 = Vector3.Distance(((Component)StartOfRound.Instance.audioListener).transform.position, pos);
				if (num2 < 15f)
				{
					HUDManager.Instance.ShakeCamera((ScreenShakeType)1);
				}
				else if (num2 < 25f)
				{
					HUDManager.Instance.ShakeCamera((ScreenShakeType)0);
				}
				return true;
			}
			return false;
		}

		[ServerRpc(RequireOwnership = false)]
		public void BreakTerrainObstacleServerRpc(Vector3 pos, int damage, 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			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(3355487482u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref pos);
					BytePacker.WriteValueBitPacked(val2, damage);
					BytePacker.WriteValueBitPacked(val2, playerWhoSent);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3355487482u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					BreakTerrainObstacleClientRpc(pos, damage, playerWhoSent);
				}
			}
		}

		[ClientRpc]
		public void BreakTerrainObstacleClientRpc(Vector3 pos, int damage, 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2193294584u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref pos);
					BytePacker.WriteValueBitPacked(val2, damage);
					BytePacker.WriteValueBitPacked(val2, playerWhoSent);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2193294584u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && (int)GameNetworkManager.Instance.localPlayerController.playerClientId != playerWhoSent)
				{
					DestroyTerrainObstacleAtPosition(pos, damage);
				}
			}
		}

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

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_JLLNetworkManager()
		{
			//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(3355487482u, new RpcReceiveHandler(__rpc_handler_3355487482));
			NetworkManager.__rpc_func_table.Add(2193294584u, new RpcReceiveHandler(__rpc_handler_2193294584));
		}

		private static void __rpc_handler_3355487482(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				int damage = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref damage);
				int playerWhoSent = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerWhoSent);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((JLLNetworkManager)(object)target).BreakTerrainObstacleServerRpc(pos, damage, playerWhoSent);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2193294584(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				int damage = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref damage);
				int playerWhoSent = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerWhoSent);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((JLLNetworkManager)(object)target).BreakTerrainObstacleClientRpc(pos, damage, playerWhoSent);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "JLLNetworkManager";
		}
	}
}
namespace JLL.API.LevelProperties
{
	[Serializable]
	public class JLevelProperties
	{
		public EnemyPropertyOverride[] enemyPropertyOverrides = new EnemyPropertyOverride[0];

		public LevelPrefab[] levelPrefabs = new LevelPrefab[0];

		public void MergeWith(JLevelProperties other)
		{
			List<EnemyPropertyOverride> list = enemyPropertyOverrides.ToList();
			list.AddRange(other.enemyPropertyOverrides);
			enemyPropertyOverrides = list.ToArray();
			List<LevelPrefab> list2 = levelPrefabs.ToList();
			list2.AddRange(other.levelPrefabs);
			levelPrefabs = list2.ToArray();
		}
	}
	[Serializable]
	public class EnemyPropertyOverride
	{
		public EnemyType enemyType;

		public float PowerLevel = -1f;

		public int MaxCount = -1;
	}
	[Serializable]
	public class LevelPrefab
	{
		public GameObject prefab;

		public Vector3 position;

		public Quaternion rotation;
	}
	public class JLevelPropertyRegistry
	{
		private static readonly Dictionary<string, JLevelProperties> Registry = new Dictionary<string, JLevelProperties>();

		public static readonly List<EnemyType> AllSortedEnemies = new List<EnemyType>();

		public static readonly List<EntranceTeleport> EntranceTeleports = new List<EntranceTeleport>();

		private static JLevelProperties original = new JLevelProperties();

		public static JLevelProperties GetLevelProperties(SelectableLevel level)
		{
			return GetLevelProperties(((Object)level).name);
		}

		public static JLevelProperties GetLevelProperties(string name)
		{
			if (Registry.TryGetValue(name, out JLevelProperties value))
			{
				return value;
			}
			return new JLevelProperties();
		}

		public static void RegisterLevelProperties(SelectableLevel level, JLevelProperties properties)
		{
			RegisterLevelProperties(((Object)level).name, properties);
		}

		public static void RegisterLevelProperties(string name, JLevelProperties properties)
		{
			if (Registry.TryGetValue(name, out JLevelProperties value))
			{
				value.MergeWith(properties);
			}
			else
			{
				Registry.Add(name, properties);
			}
		}

		public static bool HasEntranceTeleports()
		{
			return EntranceTeleports.Count > 0;
		}

		public static Vector3? GetEntranceTeleportLocation(int id = 0, bool getOutsideEntrance = false, bool getTeleportPosition = false)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < EntranceTeleports.Count; i++)
			{
				if (EntranceTeleports[i].entranceId == id && getOutsideEntrance == EntranceTeleports[i].isEntranceToBuilding)
				{
					if (getTeleportPosition)
					{
						return EntranceTeleports[i].entrancePoint.position;
					}
					return ((Component)EntranceTeleports[i]).transform.position;
				}
			}
			return null;
		}

		internal static void ApplyLevelOverrides()
		{
			//IL_0053: 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)
			EntranceTeleport[] collection = Object.FindObjectsOfType<EntranceTeleport>(false);
			EntranceTeleports.AddRange(collection);
			SelectableLevel currentLevel = RoundManager.Instance.currentLevel;
			JLevelProperties levelProperties = GetLevelProperties(currentLevel);
			LevelPrefab[] levelPrefabs = levelProperties.levelPrefabs;
			foreach (LevelPrefab levelPrefab in levelPrefabs)
			{
				GameObject val = Object.Instantiate<GameObject>(levelPrefab.prefab);
				val.transform.position = levelPrefab.position;
				val.transform.rotation = levelPrefab.rotation;
			}
			List<EnemyPropertyOverride> list = new List<EnemyPropertyOverride>();
			EnemyPropertyOverride[] enemyPropertyOverrides = levelProperties.enemyPropertyOverrides;
			foreach (EnemyPropertyOverride enemyPropertyOverride in enemyPropertyOverrides)
			{
				EnemyPropertyOverride enemyPropertyOverride2 = new EnemyPropertyOverride();
				EnemyType registeredEnemy = GetRegisteredEnemy(enemyPropertyOverride.enemyType);
				if (enemyPropertyOverride.MaxCount >= 0)
				{
					enemyPropertyOverride2.MaxCount = registeredE