using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;
using ArtifactGroup;
using BepInEx;
using BepInEx.Configuration;
using GameNetcodeStuff;
using LethalChaos;
using LethalChaos.EntropySystem.Hook_Sources;
using LethalChaos.EntropySystem.MonsterSpawner;
using LethalChaos.EntropySystem.Networking;
using LethalChaos.EntropySystem.PrefabScripts;
using LethalChaos.EntropySystem.Util;
using LethalChaos.NetcodePatcher;
using LethalCompanyInputUtils.Api;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using On;
using On.GameNetcodeStuff;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.InputSystem;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.UI;

[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("LethalChaos")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("A horrifying plugin that randomizes aspects of each planet, causing actions to be linked to a set of game events, with a probability to trigger")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+47b7122209fa7d564e60c8a60cee2d4f0d75de20")]
[assembly: AssemblyProduct("LethalChaos")]
[assembly: AssemblyTitle("LethalChaos")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class ClockHook
{
	[Serializable]
	[CompilerGenerated]
	private sealed class <>c
	{
		public static readonly <>c <>9 = new <>c();

		public static hook_MoveGlobalTime <>9__0_0;

		internal void <.ctor>b__0_0(orig_MoveGlobalTime orig, TimeOfDay self)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			RoundManager instance = RoundManager.Instance;
			GameObject val = new GameObject();
			val.transform.position = instance.insideAINodes[EntropyEngine.rnd.Next(0, instance.insideAINodes.Length)].transform.position;
			EntropyEngine.getMoonHost().queueHook("ClockIn", val, isSelective: true, targetIsPlayer: true);
			Object.Destroy((Object)(object)val);
			GameObject val2 = new GameObject();
			val2.transform.position = instance.outsideAINodes[EntropyEngine.rnd.Next(0, instance.outsideAINodes.Length)].transform.position;
			EntropyEngine.getMoonHost().queueHook("ClockOut", val2, isSelective: true, targetIsPlayer: true);
			Object.Destroy((Object)(object)val2);
		}
	}

	public ClockHook()
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Expected O, but got Unknown
		Debug.Log((object)"Lethal Chaos: Hooking  World Modifiers... ");
		try
		{
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				hook_MoveGlobalTime val = delegate(orig_MoveGlobalTime orig, TimeOfDay self)
				{
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0015: Expected O, but got Unknown
					//IL_003a: Unknown result type (might be due to invalid IL or missing references)
					//IL_005f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0065: Expected O, but got Unknown
					//IL_008a: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					RoundManager instance = RoundManager.Instance;
					GameObject val2 = new GameObject();
					val2.transform.position = instance.insideAINodes[EntropyEngine.rnd.Next(0, instance.insideAINodes.Length)].transform.position;
					EntropyEngine.getMoonHost().queueHook("ClockIn", val2, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val2);
					GameObject val3 = new GameObject();
					val3.transform.position = instance.outsideAINodes[EntropyEngine.rnd.Next(0, instance.outsideAINodes.Length)].transform.position;
					EntropyEngine.getMoonHost().queueHook("ClockOut", val3, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val3);
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			TimeOfDay.MoveGlobalTime += (hook_MoveGlobalTime)obj;
		}
		catch (Exception ex)
		{
			Debug.LogError((object)ex);
		}
	}
}
public class Ball : MonoBehaviour
{
	private Transform myTransform;

	public Transform parent;

	public GameObject Player1;

	public PlayerControllerB playerTarget;

	public GameObject NPC;

	public GameObject game;

	public CanvasScaler scaler;

	public float ballSpeed;

	public float vertSpeed = 0f;

	private Vector3 direction = Vector3.left;

	private Vector3 directionUp = Vector3.up;

	public static int Player1Score;

	public static int Player2Score;

	private void Start()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		myTransform = ((Component)this).transform;
		myTransform.position = ((Component)parent).transform.position + new Vector3(0f, 0.5f, 0f);
	}

	private void Update()
	{
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0130: Unknown result type (might be due to invalid IL or missing references)
		float num = ballSpeed * (scaler.scaleFactor / 20f);
		float num2 = vertSpeed * (scaler.scaleFactor / 20f);
		myTransform.Translate(direction * num * Time.deltaTime);
		myTransform.Translate(directionUp * num2 * Time.deltaTime);
		if ((double)myTransform.localPosition.x < -10.5)
		{
			Player2Score++;
			myTransform.localPosition = new Vector3(0f, 0.5f, 0f);
			ballSpeed = 100f;
			entropyBlaster.pongExecute(playerTarget);
			Object.Destroy((Object)(object)game);
			entropyBlaster.playingPong = false;
		}
		if ((double)myTransform.localPosition.x > 10.5)
		{
			Player1Score++;
			myTransform.localPosition = new Vector3(0f, 0.5f, 0f);
			ballSpeed = 100f;
			Object.Destroy((Object)(object)game);
			entropyBlaster.playingPong = false;
		}
	}

	private void OnTriggerEnter2D(Collider2D collider)
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		if (((Object)collider).name.Equals("Player1Middle") || ((Object)collider).name.Equals("Player"))
		{
			direction = Vector3.right;
			vertSpeed = Random.Range((0f - ballSpeed) * 2f, ballSpeed * 2f);
			ballSpeed += 25f;
		}
		if (((Object)collider).name.Equals("NPC"))
		{
			direction = Vector3.left;
			vertSpeed = Random.Range((0f - ballSpeed) * 2f, ballSpeed * 2f);
			NPC.GetComponent<NPC>().skill -= 3;
			ballSpeed += 25f;
		}
		if (((Object)collider).name.Equals("TopBoundary"))
		{
			Debug.Log((object)"TopBoundaryCollide");
			vertSpeed = Math.Abs(vertSpeed) * -1f;
		}
		if (((Object)collider).name.Equals("BottomBoundary"))
		{
			Debug.Log((object)"BottomBoundaryCollide");
			vertSpeed = Math.Abs(vertSpeed);
		}
	}
}
public class InputMap : LcInputActions
{
	[InputAction(/*Could not decode attribute arguments.*/)]
	public InputAction pongUp { get; set; }

	[InputAction(/*Could not decode attribute arguments.*/)]
	public InputAction pongUpAlt { get; set; }

	[InputAction(/*Could not decode attribute arguments.*/)]
	public InputAction pongDown { get; set; }

	[InputAction(/*Could not decode attribute arguments.*/)]
	public InputAction pongDownAlt { get; set; }
}
public class myGUI : MonoBehaviour
{
	private void Start()
	{
	}

	private void Update()
	{
	}

	private void OnGUI()
	{
	}
}
public class NPC : MonoBehaviour
{
	private Transform myTransform;

	public Transform parent;

	public GameObject Ball;

	private float vert;

	public int skill = 34;

	public CanvasScaler scaler;

	public GameObject DeadNPC;

	private void Start()
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		myTransform = ((Component)this).transform;
		myTransform.position = new Vector3(8f, vert, 0f) + ((Component)parent).transform.position;
	}

	private void Update()
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: 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_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		float num = scaler.scaleFactor / 20f;
		vert = Ball.transform.position.y;
		myTransform.localPosition = new Vector3(8f, Mathf.Lerp(myTransform.localPosition.y, Ball.transform.localPosition.y, Time.deltaTime * num * ((float)skill / 10f) * 4f), 0f);
		Vector3 val = default(Vector3);
		((Vector3)(ref val))..ctor(myTransform.localPosition.x, myTransform.localPosition.y, myTransform.localPosition.z);
		if (skill < 1)
		{
			Object.Instantiate<GameObject>(DeadNPC, val, Quaternion.identity);
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}

	private void OnTriggerEnter(Collider collider)
	{
		if (((Component)collider).CompareTag("Ball"))
		{
			skill -= 4;
		}
	}
}
public class Player1Bottom : MonoBehaviour
{
	private Transform myTransform;

	public Transform parent;

	public int playerSpeed = 10;

	private void Start()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		myTransform = ((Component)this).transform;
		myTransform.position = ((Component)parent).transform.position + new Vector3(-8f, -0.5f, 0f);
	}

	private void Update()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
		if (Input.GetKey((KeyCode)119))
		{
			myTransform.Translate(Vector3.up * (float)playerSpeed * Time.deltaTime);
		}
		if (Input.GetKey((KeyCode)115))
		{
			myTransform.Translate(Vector3.down * (float)playerSpeed * Time.deltaTime);
		}
		if (myTransform.localPosition.y > 5f)
		{
			myTransform.localPosition = new Vector3(-8f, 5f, 0f);
		}
		if (myTransform.localPosition.y < -5f)
		{
			myTransform.localPosition = new Vector3(-8f, -5f, 0f);
		}
	}
}
public class Player1Middle : MonoBehaviour
{
	private Transform myTransform;

	public Transform parent;

	public CanvasScaler scaler;

	public int playerSpeed;

	private void Start()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		myTransform = ((Component)this).transform;
		myTransform.position = ((Component)parent).transform.position + new Vector3(-8f, 0.5f, 0f);
	}

	private void Update()
	{
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_015b: Unknown result type (might be due to invalid IL or missing references)
		float num = scaler.scaleFactor / 20f;
		if (Plugin.controls.pongUp.IsPressed() || Plugin.controls.pongUpAlt.IsPressed())
		{
			myTransform.Translate(Vector3.up * (float)playerSpeed * num * Time.deltaTime);
		}
		if (Plugin.controls.pongDown.IsPressed() || Plugin.controls.pongDownAlt.IsPressed())
		{
			myTransform.Translate(Vector3.down * (float)playerSpeed * num * Time.deltaTime);
		}
		if (myTransform.localPosition.y > 7f)
		{
			myTransform.localPosition = new Vector3(myTransform.localPosition.x, 6f, myTransform.localPosition.z);
		}
		if (myTransform.localPosition.y < -8f)
		{
			myTransform.localPosition = new Vector3(myTransform.localPosition.x, -6f, myTransform.localPosition.z);
		}
	}
}
public class Player1Top : MonoBehaviour
{
	private Transform myTransform;

	public Transform parent;

	public int playerSpeed = 10;

	private void Start()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		myTransform = ((Component)this).transform;
		myTransform.position = ((Component)parent).transform.position + new Vector3(-8f, 1.5f, 0f);
	}

	private void Update()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
		if (Input.GetKey((KeyCode)119))
		{
			myTransform.Translate(Vector3.up * (float)playerSpeed * Time.deltaTime);
		}
		if (Input.GetKey((KeyCode)115))
		{
			myTransform.Translate(Vector3.down * (float)playerSpeed * Time.deltaTime);
		}
		if (myTransform.localPosition.y > 7f)
		{
			myTransform.localPosition = new Vector3(-8f, 7f, 0f);
		}
		if (myTransform.localPosition.y < -3f)
		{
			myTransform.localPosition = new Vector3(-8f, -3f, 0f);
		}
	}
}
public class Player2Bottom : MonoBehaviour
{
	private Transform myTransform;

	public int playerSpeed = 10;

	private void Start()
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		myTransform = ((Component)this).transform;
		myTransform.position = new Vector3(8f, -0.5f, 0f);
	}

	private void Update()
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		if (Input.GetKey((KeyCode)273))
		{
			myTransform.Translate(Vector3.up * (float)playerSpeed * Time.deltaTime);
		}
		if (Input.GetKey((KeyCode)274))
		{
			myTransform.Translate(Vector3.down * (float)playerSpeed * Time.deltaTime);
		}
		if (myTransform.position.y > 5f)
		{
			myTransform.position = new Vector3(8f, 5f, 0f);
		}
		if (myTransform.position.y < -5f)
		{
			myTransform.position = new Vector3(8f, -5f, 0f);
		}
	}
}
public class Player2Middle : MonoBehaviour
{
	private Transform myTransform;

	public int playerSpeed = 10;

	private void Start()
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		myTransform = ((Component)this).transform;
		myTransform.position = new Vector3(8f, 0.5f, 0f);
	}

	private void Update()
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		if (Input.GetKey((KeyCode)273))
		{
			myTransform.Translate(Vector3.up * (float)playerSpeed * Time.deltaTime);
		}
		if (Input.GetKey((KeyCode)274))
		{
			myTransform.Translate(Vector3.down * (float)playerSpeed * Time.deltaTime);
		}
		if (myTransform.position.y > 7f)
		{
			myTransform.position = new Vector3(8f, 6f, 0f);
		}
		if (myTransform.position.y < -5f)
		{
			myTransform.position = new Vector3(8f, -4f, 0f);
		}
	}
}
public class Player2Top : MonoBehaviour
{
	private Transform myTransform;

	public int playerSpeed = 10;

	private void Start()
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		myTransform = ((Component)this).transform;
		myTransform.position = new Vector3(8f, 1.5f, 0f);
	}

	private void Update()
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		if (Input.GetKey((KeyCode)273))
		{
			myTransform.Translate(Vector3.up * (float)playerSpeed * Time.deltaTime);
		}
		if (Input.GetKey((KeyCode)274))
		{
			myTransform.Translate(Vector3.down * (float)playerSpeed * Time.deltaTime);
		}
		if (myTransform.position.y > 7f)
		{
			myTransform.position = new Vector3(8f, 7f, 0f);
		}
		if (myTransform.position.y < -3f)
		{
			myTransform.position = new Vector3(8f, -3f, 0f);
		}
	}
}
public class Score : MonoBehaviour
{
	private void Start()
	{
	}

	private void Update()
	{
	}

	private void OnGUI()
	{
	}
}
namespace ArtifactGroup
{
	public class entropyBlaster
	{
		public static Random r = new Random();

		public static Transform btransform = new GameObject().transform;

		public static GameObject spoderRef;

		public static bool playingPong = false;

		public static bool meteorsToday = false;

		public static bool oneOrMorePlayersInFactory()
		{
			try
			{
				GameObject[] players = getPlayers();
				GameObject[] array = players;
				foreach (GameObject val in array)
				{
					PlayerControllerB component = val.GetComponent<PlayerControllerB>();
					if ((Object)(object)component != (Object)null && component.isInsideFactory)
					{
						return true;
					}
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Lethal Chaos: oneOrMorePlayersInFactory method failure -> " + ex.ToString()));
			}
			return false;
		}

		public static bool playerInFactory(GameObject player)
		{
			PlayerControllerB component = player.GetComponent<PlayerControllerB>();
			return component.isInsideFactory;
		}

		public static float nearestPlayerToCoordDistance(Vector3 position)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject[] players = getPlayers();
				float num = float.PositiveInfinity;
				GameObject[] array = players;
				foreach (GameObject val in array)
				{
					Vector3 val2 = val.transform.position - position;
					float magnitude = ((Vector3)(ref val2)).magnitude;
					if (magnitude < num)
					{
						num = magnitude;
					}
				}
				return num;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Lethal Chaos: nearestPlayerToCoordDistance method failure -> " + ex.ToString()));
			}
			return 0f;
		}

		public static GameObject nearestPlayerToCoord(Vector3 position)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			GameObject result = null;
			try
			{
				GameObject[] players = getPlayers();
				float num = float.PositiveInfinity;
				GameObject[] array = players;
				foreach (GameObject val in array)
				{
					Vector3 val2 = val.transform.position - position;
					float magnitude = ((Vector3)(ref val2)).magnitude;
					if (magnitude < num)
					{
						num = magnitude;
						result = val;
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Lethal Chaos: nearestPlayerToCoord method failure -> " + ex.ToString()));
			}
			return result;
		}

		public static GameObject[] getPlayers()
		{
			return GameObject.FindGameObjectsWithTag("Player");
		}

		public static Vector3 safeNodePosition(GameObject target, float inner_threshold, float outer_threshold, int areaCode)
		{
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val = nearestPlayerToCoord(target.transform.position);
				PlayerControllerB component = val.GetComponent<PlayerControllerB>();
				GameObject[] array = null;
				RoundManager instance = RoundManager.Instance;
				if (component.isInsideFactory && areaCode == 2)
				{
					return Vector3.zero;
				}
				if (!component.isInsideFactory && areaCode == 1)
				{
					return Vector3.zero;
				}
				array = ((!component.isInsideFactory) ? instance.outsideAINodes : instance.insideAINodes);
				List<GameObject> list = new List<GameObject>();
				GameObject[] array2 = array;
				foreach (GameObject val2 in array2)
				{
					float num = nearestPlayerToCoordDistance(val2.transform.position);
					if (num > inner_threshold && num < outer_threshold)
					{
						list.Add(val2);
					}
				}
				if (list.Count != 0)
				{
					return list[EntropyEngine.rnd.Next(0, list.Count)].transform.position;
				}
				return Vector3.zero;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)ex);
				return Vector3.zero;
			}
		}

		public static Vector3 safeRandomizedPositionFlex(GameObject target, float inner_threshold, float outer_threshold, int areaCode, NavMeshHit navHit = default(NavMeshHit))
		{
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector3 val2 = default(Vector3);
				for (int i = 0; i < 5; i++)
				{
					RoundManager instance = RoundManager.Instance;
					GameObject val = nearestPlayerToCoord(target.transform.position);
					PlayerControllerB component = val.GetComponent<PlayerControllerB>();
					if (component.isInsideFactory && areaCode == 2)
					{
						return Vector3.zero;
					}
					if (!component.isInsideFactory && areaCode == 1)
					{
						return Vector3.zero;
					}
					int num = 1;
					int num2 = 1;
					if (EntropyEngine.rnd.NextDouble() < 0.5)
					{
						num = -1;
					}
					if (EntropyEngine.rnd.NextDouble() < 0.5)
					{
						num2 = -1;
					}
					int num3 = 5;
					while (num3 > 0)
					{
						num3--;
						try
						{
							outer_threshold -= inner_threshold;
							float num4 = val.transform.position.x + (inner_threshold + outer_threshold * (float)EntropyEngine.rnd.NextDouble()) * (float)num;
							float num5 = val.transform.position.z + (inner_threshold + outer_threshold * (float)EntropyEngine.rnd.NextDouble()) * (float)num2;
							((Vector3)(ref val2))..ctor(num4, val.transform.position.y, num5);
							if (NavMesh.SamplePosition(val2, ref navHit, outer_threshold, -1) && avoidsAllPlayers(inner_threshold, ((NavMeshHit)(ref navHit)).position))
							{
								return ((NavMeshHit)(ref navHit)).position;
							}
						}
						catch (Exception)
						{
							num3--;
						}
					}
					Debug.Log((object)"Lethal Chaos: Position Flex failed, trying safeRandomizedPosition");
				}
				return safeNodePosition(target, inner_threshold, outer_threshold, areaCode);
			}
			catch (Exception ex2)
			{
				Debug.LogError((object)ex2);
				return Vector3.zero;
			}
		}

		public static bool avoidsAllPlayers(float inner_threshold, Vector3 pos)
		{
			//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)
			RoundManager instance = RoundManager.Instance;
			PlayerControllerB[] allPlayerScripts = instance.playersManager.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)((Component)val).gameObject) && Vector3.Distance(((Component)val).gameObject.transform.position, pos) < inner_threshold)
				{
					return false;
				}
			}
			return true;
		}

		public static void bomb(GameObject target, bool targetIsPlayer)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: Bomb Trigger");
			Vector3 zero = Vector3.zero;
			if (targetIsPlayer)
			{
				zero = safeRandomizedPositionFlex(target, 8f * Accumulators.explosionSafetyMult + 5f, 30f, 0);
				Accumulators.explosionSafetyMult *= 0.9f;
			}
			else
			{
				zero = target.transform.position;
			}
			if (zero != Vector3.zero)
			{
				Plugin.rpcCalls.spawnExplosionClientRpc(zero);
			}
		}

		public static void SpawnRandomOutsideEnemyNear(GameObject target, bool targetIsPlayer)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: Random Outside EnemyTrigger");
			RoundManager instance = RoundManager.Instance;
			Vector3 zero = Vector3.zero;
			if (targetIsPlayer)
			{
				zero = safeRandomizedPositionFlex(target, 3f, 25f, 2);
				if (zero != Vector3.zero && EntropyEngine.rnd.NextDouble() < (double)Accumulators.enemySpawnMult)
				{
					int index = EntropyEngine.rnd.Next(0, instance.currentLevel.OutsideEnemies.Count);
					GameObject val = Object.Instantiate<GameObject>(instance.currentLevel.OutsideEnemies[index].enemyType.enemyPrefab, zero, Quaternion.Euler(Vector3.zero));
					val.gameObject.GetComponentInChildren<NetworkObject>().Spawn(true);
					instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
					EnemyType enemyType = val.GetComponent<EnemyAI>().enemyType;
					enemyType.numberSpawned++;
					EntityDestructionManager.destroyOnLeave.Add(val);
					Accumulators.enemySpawnMult *= 0.95f;
				}
				else
				{
					EventThrottler.summons -= 1f;
					EventThrottler.triggerTotals[1]--;
				}
			}
			else
			{
				EventThrottler.summons -= 1f;
				EventThrottler.triggerTotals[1]--;
			}
		}

		public static void SpawnRandomInsideEnemyNear(GameObject target, bool targetIsPlayer)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: Random Inside EnemyTrigger");
			RoundManager instance = RoundManager.Instance;
			Vector3 zero = Vector3.zero;
			if (targetIsPlayer)
			{
				zero = safeRandomizedPositionFlex(target, 3f, 15f, 1);
				if (zero != Vector3.zero && EntropyEngine.rnd.NextDouble() < (double)Accumulators.enemySpawnMult)
				{
					int index = EntropyEngine.rnd.Next(0, instance.currentLevel.OutsideEnemies.Count);
					GameObject val = Object.Instantiate<GameObject>(instance.currentLevel.Enemies[index].enemyType.enemyPrefab, zero, Quaternion.Euler(Vector3.zero));
					val.gameObject.GetComponentInChildren<NetworkObject>().Spawn(true);
					instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
					EnemyType enemyType = val.GetComponent<EnemyAI>().enemyType;
					enemyType.numberSpawned++;
					EntityDestructionManager.destroyOnLeave.Add(val);
					Accumulators.enemySpawnMult *= 0.9f;
				}
				else
				{
					EventThrottler.summons -= 1f;
					EventThrottler.triggerTotals[5]--;
				}
			}
			else
			{
				EventThrottler.summons -= 1f;
				EventThrottler.triggerTotals[5]--;
			}
		}

		public static void spawnRandomEnemy(GameObject target)
		{
		}

		public static void spawnRandomHazard(GameObject target, bool targetIsPlayer)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: Spawn Random Hazard Trigger");
			Vector3 zero = Vector3.zero;
			Quaternion rotation = Random.rotation;
			zero = ((!targetIsPlayer) ? target.transform.position : safeRandomizedPositionFlex(target, 12f, 20f, 0));
			if (!(zero == Vector3.zero))
			{
				RoundManager instance = RoundManager.Instance;
				int num = EntropyEngine.rnd.Next(0, instance.currentLevel.spawnableMapObjects.Length);
				GameObject val = Object.Instantiate<GameObject>(instance.currentLevel.spawnableMapObjects[num].prefabToSpawn, zero, Quaternion.identity, btransform);
				val.GetComponent<NetworkObject>().Spawn(true);
				EntityDestructionManager.destroyOnLeave.Add(val);
			}
		}

		public static void spawnTurret(GameObject target, bool targetIsPlayer)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: Spawn Turret Trigger");
			Quaternion rotation = Random.rotation;
			Vector3 zero = Vector3.zero;
			zero = ((!targetIsPlayer) ? target.transform.position : safeRandomizedPositionFlex(target, 12f, 40f, 0));
			if (!(zero == Vector3.zero))
			{
				RoundManager instance = RoundManager.Instance;
				GameObject val = Object.Instantiate<GameObject>(instance.currentLevel.spawnableMapObjects[1].prefabToSpawn, zero, Quaternion.identity, btransform);
				val.GetComponent<NetworkObject>().Spawn(true);
				EntityDestructionManager.destroyOnLeave.Add(val);
			}
		}

		public static void spawnMine(GameObject target, bool targetIsPlayer)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: Spawn Mine Trigger");
			Vector3 zero = Vector3.zero;
			zero = ((!targetIsPlayer) ? target.transform.position : safeRandomizedPositionFlex(target, 10f, 20f, 0));
			if (!(zero == Vector3.zero))
			{
				RoundManager instance = RoundManager.Instance;
				GameObject val = Object.Instantiate<GameObject>(instance.currentLevel.spawnableMapObjects[0].prefabToSpawn, zero, Quaternion.identity, btransform);
				val.GetComponent<NetworkObject>().Spawn(true);
				EntityDestructionManager.destroyOnLeave.Add(val);
			}
		}

		public GameObject[] FindGameObjectsWithLayer(int layer)
		{
			GameObject[] array = Object.FindObjectsOfType<GameObject>();
			List<GameObject> list = new List<GameObject>();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].layer == layer)
				{
					list.Add(array[i]);
				}
			}
			if (list.Count == 0)
			{
				return null;
			}
			return list.ToArray();
		}

		public static void spawnHive(GameObject target, bool targetIsPlayer)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			RoundManager instance = RoundManager.Instance;
			Quaternion rotation = Random.rotation;
			Debug.Log((object)"Lethal Chaos: Spawn Hive Trigger");
			Vector3 zero = Vector3.zero;
			if (targetIsPlayer)
			{
				zero = safeRandomizedPositionFlex(target, 12f, 60f, 2);
				if (!(zero == Vector3.zero))
				{
					RedLocustBees[] array = Resources.FindObjectsOfTypeAll<RedLocustBees>();
					RedLocustBees val = array[0];
					Debug.Log((object)("bee obj: " + ((Object)val).name + " - " + ((object)val).GetType()?.ToString() + " - " + ((object)val).ToString()));
					GameObject gameObject = ((Component)val).gameObject;
					GameObject val2 = Object.Instantiate<GameObject>(gameObject, zero, Quaternion.identity, new GameObject().transform);
					val2.GetComponentInChildren<NetworkObject>().Spawn(true);
					instance.SpawnedEnemies.Add(val2.GetComponent<EnemyAI>());
					val2.SetActive(true);
				}
			}
		}

		public static void spawnRandomPropInside(GameObject target, bool targetIsPlayer)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			RoundManager instance = RoundManager.Instance;
			Vector3 zero = Vector3.zero;
			zero = ((!targetIsPlayer) ? target.transform.position : safeRandomizedPositionFlex(target, 7f, 15f, 0));
			if (zero == Vector3.zero)
			{
				return;
			}
			try
			{
				SpawnSyncedObject[] array = Object.FindObjectsOfType<SpawnSyncedObject>();
				if (array != null)
				{
					instance.mapPropsContainer = GameObject.FindGameObjectWithTag("MapPropsContainer");
					Debug.Log((object)$"Lethal Chaos: Spawning synced inside prop on server. Choices Length: {array.Length}");
					int num = EntropyEngine.rnd.Next(0, array.Length);
					GameObject val = Object.Instantiate<GameObject>(array[num].spawnPrefab, zero, target.transform.rotation, new GameObject().transform);
					if ((Object)(object)val != (Object)null)
					{
						val.GetComponent<NetworkObject>().Spawn(true);
						instance.spawnedSyncedObjects.Add(val);
						EntityDestructionManager.destroyOnLeave.Add(val);
					}
				}
			}
			catch (Exception arg)
			{
				Debug.Log((object)$"Exception! Unable to sync spawned objects on host; {arg}");
			}
		}

		public static void spawnRandomPropOutside(GameObject target, bool targetIsPlayer)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			RoundManager instance = RoundManager.Instance;
			Vector3 zero = Vector3.zero;
			zero = ((!targetIsPlayer) ? target.transform.position : safeRandomizedPositionFlex(target, 7f, 40f, 0));
			if (zero == Vector3.zero)
			{
				return;
			}
			try
			{
				SpawnSyncedObject[] array = Object.FindObjectsOfType<SpawnSyncedObject>();
				if (array != null)
				{
					instance.mapPropsContainer = GameObject.FindGameObjectWithTag("MapPropsContainer");
					Debug.Log((object)$"Lethal Chaos: Spawning synced outside prop on server. Choices Length: {array.Length}");
					int num = EntropyEngine.rnd.Next(0, array.Length);
					GameObject val = Object.Instantiate<GameObject>(array[num].spawnPrefab, zero, target.transform.rotation, new GameObject().transform);
					if ((Object)(object)val != (Object)null)
					{
						val.GetComponent<NetworkObject>().Spawn(true);
						instance.spawnedSyncedObjects.Add(val);
						EntityDestructionManager.destroyOnLeave.Add(val);
					}
				}
			}
			catch (Exception arg)
			{
				Debug.Log((object)$"Exception! Unable to sync spawned objects on host; {arg}");
			}
		}

		public static void spawnRandomItem(GameObject target, int id, bool targetIsPlayer)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			RoundManager instance = RoundManager.Instance;
			try
			{
				Debug.Log((object)"Lethal Chaos: Spawning synced item on server.");
				Vector3 zero = Vector3.zero;
				Quaternion rotation = Random.rotation;
				zero = ((!targetIsPlayer) ? target.transform.position : safeRandomizedPositionFlex(target, 3f, 20f, 0));
				if (!(zero == Vector3.zero) && EntropyEngine.rnd.NextDouble() < (double)Accumulators.itemGetMult)
				{
					Item spawnableItem = instance.currentLevel.spawnableScrap[id].spawnableItem;
					GameObject val = Object.Instantiate<GameObject>(spawnableItem.spawnPrefab, zero, Quaternion.identity, new GameObject().transform);
					GrabbableObject component = val.GetComponent<GrabbableObject>();
					((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
					component.fallTime = 0f;
					component.scrapValue = (int)((float)EntropyEngine.rnd.Next(spawnableItem.minValue, spawnableItem.maxValue) * instance.scrapValueMultiplier);
					component.SetScrapValue(component.scrapValue);
					NetworkObject component2 = val.GetComponent<NetworkObject>();
					component2.Spawn(false);
					int[] array = new int[1] { component.scrapValue };
					NetworkObjectReference[] array2 = (NetworkObjectReference[])(object)new NetworkObjectReference[1] { NetworkObjectReference.op_Implicit(component2) };
					Accumulators.itemGetMult *= 0.7f;
					val.GetComponent<GrabbableObject>().SetScrapValue(component.scrapValue);
					EntityDestructionManager.destroyOnFail.Add(val);
				}
			}
			catch (Exception arg)
			{
				Debug.Log((object)$"Exception! Unable to sync spawned objects on host; {arg}");
			}
		}

		public static void teleportPlayer(GameObject target, bool targetIsPlayer)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (targetIsPlayer)
			{
				Debug.Log((object)"Lethal Chaos: Teleporting Player.");
				GameObject val = nearestPlayerToCoord(target.transform.position);
				PlayerControllerB component = val.GetComponent<PlayerControllerB>();
				Vector3 zero = Vector3.zero;
				zero = safeRandomizedPositionFlex(target, 0f, 25f, 0);
				Plugin.rpcCalls.teleportPlayerClientRpc(((NetworkBehaviour)component).NetworkObjectId, zero);
			}
		}

		public static void LBolt(GameObject target, bool targetIsPlayer)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			RoundManager instance = RoundManager.Instance;
			Debug.Log((object)"Lethal Chaos: Spawning LBolt");
			Vector3 zero = Vector3.zero;
			if (targetIsPlayer)
			{
				Accumulators.lightningSafetyMult *= 0.96f;
				zero = safeRandomizedPositionFlex(target, 4f, 40f * Accumulators.lightningSafetyMult + 15f, 0);
			}
			else
			{
				zero = target.transform.position;
			}
			if (!(zero == Vector3.zero))
			{
				Plugin.rpcCalls.lightningStrikeClientRpc(zero);
			}
		}

		public static void drunk(GameObject target, bool targetIsPlayer)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: Making Player Drunk.");
			GameObject val = nearestPlayerToCoord(target.transform.position);
			PlayerControllerB component = val.GetComponent<PlayerControllerB>();
			Plugin.rpcCalls.makePlayerDrunkClientRpc(((NetworkBehaviour)component).NetworkObjectId);
		}

		public static async void lightFlicker()
		{
			Debug.Log((object)"Flickering Player Lights");
			Plugin.rpcCalls.lightFlickerClientRpc();
		}

		public static void timeJumpForward()
		{
			Debug.Log((object)"Lethal Chaos: Jumping Time Forward");
			Plugin.rpcCalls.timeJumpForwardClientRpc();
		}

		public static void timeJumpBackward()
		{
		}

		public static void qsand(GameObject target, bool targetIsPlayer)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: Adding Quicksand.");
			Vector3 zero = Vector3.zero;
			if (targetIsPlayer)
			{
				zero = safeRandomizedPositionFlex(target, 0f, 120f, 0);
				if (!(zero == Vector3.zero))
				{
					Plugin.rpcCalls.qsandClientRpc(zero);
				}
			}
		}

		public static void playSoundInsane(GameObject target, bool targetIsPlayer)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: Insanity Sound.");
			Vector3 zero = Vector3.zero;
			if (targetIsPlayer)
			{
				zero = safeRandomizedPositionFlex(target, 0f, 1f, 0);
				SoundManager.Instance.PlayAudio1AtPositionClientRpc(zero, EntropyEngine.rnd.Next(0, 2));
			}
		}

		public static void indoorJumpscare(GameObject target, bool targetIsPlayer)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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)
			Debug.Log((object)"Lethal Chaos: Indoor Spook.");
			Vector3 zero = Vector3.zero;
			if (targetIsPlayer)
			{
				zero = safeRandomizedPositionFlex(target, 15f, 120f, 1);
				if (!(zero == Vector3.zero))
				{
					RoundManager.PlayRandomClip(StartOfRound.Instance.shipAmbianceAudio, StartOfRound.Instance.shipCreakSFX, false, 1f, 0, 1000);
				}
			}
		}

		public static async void wormFromHell(GameObject target, bool targetIsPlayer)
		{
			Debug.Log((object)"Lethal Chaos: Worm From Hell.");
			_ = Vector3.zero;
			Vector3 position = safeRandomizedPositionFlex(target, 0f, 45f, 0);
			Quaternion randRot = Random.rotation;
			GameObject WORMBASE = ((Component)Resources.FindObjectsOfTypeAll<SandWormAI>()[0]).gameObject;
			Debug.Log((object)("worm obj: " + (object)WORMBASE.gameObject));
			GameObject worm = Object.Instantiate<GameObject>(WORMBASE, position, randRot, new GameObject().transform);
			Debug.Log((object)("worm init: " + (object)worm));
			worm.SetActive(true);
			SandWormAI AI = worm.GetComponent<SandWormAI>();
			GameObject gameObject = Object.Instantiate<GameObject>(((EnemyAI)AI).enemyType.enemyPrefab, position, randRot);
			gameObject.GetComponentInChildren<NetworkObject>().Spawn(true);
			RoundManager.Instance.SpawnedEnemies.Add(gameObject.GetComponent<EnemyAI>());
			Debug.Log((object)("AI: " + (object)AI));
			((Object)AI).name = "gamer";
			((Object)gameObject).name = "true gamer";
			SandWormAI AI2 = gameObject.GetComponent<SandWormAI>();
			Debug.Log((object)("AI2 Comp " + (object)AI2));
			Debug.Log((object)"Lethal Chaos: Worm Emerge");
			await Task.Delay(500);
			AI2.EmergeServerRpc(0);
			await Task.Delay(10000);
			Object.Destroy((Object)(object)gameObject);
			Object.Destroy((Object)(object)worm);
		}

		public static async void funnyLadder(GameObject target, bool targetIsPlayer)
		{
			Debug.Log((object)"Lethal Chaos: Funny Ladder.");
			_ = Vector3.zero;
			Vector3 position = safeRandomizedPositionFlex(target, 5f, 25f, 0);
			Quaternion randRot = Random.rotation;
			if (!(position == Vector3.zero))
			{
				GameObject ladderbase = ((Component)Resources.FindObjectsOfTypeAll<ExtensionLadderItem>()[0]).gameObject;
				GameObject ladder = Object.Instantiate<GameObject>(ladderbase, position, randRot, new GameObject().transform);
				ExtensionLadderItem ITEM = ladder.GetComponent<ExtensionLadderItem>();
				ladder.GetComponentInChildren<NetworkObject>().Spawn(true);
				_ = ((Component)Resources.FindObjectsOfTypeAll<ExtensionLadderItem>()[0]).gameObject;
				GameObject ladder2 = Object.Instantiate<GameObject>(ladderbase, position, randRot, new GameObject().transform);
				ExtensionLadderItem ITEM2 = ladder.GetComponent<ExtensionLadderItem>();
				ladder2.GetComponentInChildren<NetworkObject>().Spawn(true);
				try
				{
					Plugin.rpcCalls.activateLadderClientRpc(((NetworkBehaviour)ITEM).NetworkObjectId);
					Plugin.rpcCalls.activateLadderClientRpc(((NetworkBehaviour)ITEM2).NetworkObjectId);
				}
				catch (Exception)
				{
					Debug.Log((object)"bruh");
				}
				await Task.Delay(25000);
				if (!((GrabbableObject)ITEM).hasBeenHeld && !((GrabbableObject)ITEM).isHeld)
				{
					Object.Destroy((Object)(object)ladder);
					Object.Destroy((Object)(object)ladder2);
				}
				else
				{
					EntityDestructionManager.destroyOnFail.Add(ladderbase);
				}
			}
		}

		public static async void funnyRadio(GameObject target, bool targetIsPlayer)
		{
			Debug.Log((object)"Lethal Chaos: Funny Radio.");
			_ = Vector3.zero;
			Quaternion randRot = Random.rotation;
			Vector3 position = safeRandomizedPositionFlex(target, 5f, 25f, 0);
			if (!(position == Vector3.zero))
			{
				GameObject ladderbase = ((Component)Resources.FindObjectsOfTypeAll<BoomboxItem>()[0]).gameObject;
				GameObject ladder = Object.Instantiate<GameObject>(ladderbase, position, randRot, new GameObject().transform);
				ExtensionLadderItem ITEM = ladder.GetComponent<ExtensionLadderItem>();
				ladder.GetComponentInChildren<NetworkObject>().Spawn(true);
				((GrabbableObject)ladder.GetComponentInChildren<BoomboxItem>()).Start();
				((GrabbableObject)ladder.GetComponent<BoomboxItem>()).ItemActivate(true, true);
				((GrabbableObject)ladder.GetComponent<BoomboxItem>()).UseItemOnClient(true);
				await Task.Delay(25000);
				if (!((GrabbableObject)ITEM).hasBeenHeld && !((GrabbableObject)ITEM).isHeld)
				{
					Object.Destroy((Object)(object)ladder);
				}
				else
				{
					EntityDestructionManager.destroyOnFail.Add(ladderbase);
				}
			}
		}

		public static async void bigBalls(GameObject target, bool targetIsPlayer)
		{
			Debug.Log((object)"Lethal Chaos: Big Balls.");
			_ = Vector3.zero;
			Vector3 position = safeRandomizedPositionFlex(target, 5f, 25f, 0);
			_ = Random.rotation;
			if (!(position == Vector3.zero))
			{
				GameObject ladderbase = ((Component)Resources.FindObjectsOfTypeAll<SoccerBallProp>()[0]).gameObject;
				GameObject ladder = Object.Instantiate<GameObject>(ladderbase, position, Quaternion.identity, new GameObject().transform);
				SoccerBallProp ITEM = ladder.GetComponent<SoccerBallProp>();
				ladder.GetComponentInChildren<NetworkObject>().Spawn(true);
				((GrabbableObject)ladder.GetComponentInChildren<SoccerBallProp>()).Start();
				Plugin.rpcCalls.bigBallsClientRpc(((NetworkBehaviour)ITEM).NetworkObjectId);
				await Task.Delay(25000);
				if (!((GrabbableObject)ITEM).hasBeenHeld && !((GrabbableObject)ITEM).isHeld)
				{
					Object.Destroy((Object)(object)ladder);
				}
				else
				{
					EntityDestructionManager.destroyOnFail.Add(ladderbase);
				}
			}
		}

		public static void meds(GameObject target, bool targetIsPlayer)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: finally some free healthcare");
			GameObject val = nearestPlayerToCoord(target.transform.position);
			PlayerControllerB component = val.GetComponent<PlayerControllerB>();
			Plugin.rpcCalls.medsClientRpc(((NetworkBehaviour)component).NetworkObjectId);
		}

		public static void fard(GameObject target, bool targetIsPlayer)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: fard");
			GameObject val = nearestPlayerToCoord(target.transform.position);
			PlayerControllerB component = val.GetComponent<PlayerControllerB>();
			Plugin.rpcCalls.fardClientRpc(((NetworkBehaviour)component).NetworkObjectId);
		}

		public static void burp(GameObject target, bool targetIsPlayer)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: burp");
			GameObject val = nearestPlayerToCoord(target.transform.position);
			PlayerControllerB component = val.GetComponent<PlayerControllerB>();
			Plugin.rpcCalls.burpClientRpc(((NetworkBehaviour)component).NetworkObjectId);
		}

		public static void stunPlayer(GameObject target, bool targetIsPlayer)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: stun");
			GameObject val = nearestPlayerToCoord(target.transform.position);
			PlayerControllerB component = val.GetComponent<PlayerControllerB>();
			Plugin.rpcCalls.stunClientRpc(((NetworkBehaviour)component).NetworkObjectId);
		}

		public static void spawnCar(GameObject target, bool targetIsPlayer)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: Spawn Car Trigger");
			Quaternion rotation = Random.rotation;
			Vector3 zero = Vector3.zero;
			zero = ((!targetIsPlayer) ? target.transform.position : safeRandomizedPositionFlex(target, 10f, 20f, 0));
			if (!(zero == Vector3.zero))
			{
				RoundManager instance = RoundManager.Instance;
				Object obj = Object.FindObjectsOfTypeAll(typeof(VehicleController))[0];
				VehicleController val = (VehicleController)(object)((obj is VehicleController) ? obj : null);
				GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, zero, rotation, new GameObject().transform);
				val2.GetComponent<NetworkObject>().Spawn(true);
				EntityDestructionManager.destroyOnLeave.Add(val2);
			}
		}

		public static void createFrontCanvas()
		{
		}

		public static void pong(GameObject target, bool targetIsPlayer)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = nearestPlayerToCoord(target.transform.position);
			if ((Object)(object)val == (Object)null)
			{
				Debug.Log((object)"Lethal Chaos: P O N G Blocked: player is null");
			}
			Plugin.rpcCalls.startPongGameClientRpc(((NetworkBehaviour)val.GetComponent<PlayerControllerB>()).NetworkObjectId);
		}

		public static void pongExecute(PlayerControllerB player)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: Pong Game lost (get rekt)");
			player.DamagePlayer(90, true, true, (CauseOfDeath)6, 2, false, default(Vector3));
		}

		public static void shipSuck()
		{
			Plugin.rpcCalls.startSuckClipClientRpc();
		}

		public static void spawnWeb(GameObject target, bool targetIsPlayer)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: 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)
			Debug.Log((object)"Lethal Chaos: Spoder Web.");
			Vector3 zero = Vector3.zero;
			zero = safeRandomizedPositionFlex(target, 5f, 25f, 0);
			Quaternion rotation = Random.rotation;
			if (zero == Vector3.zero)
			{
				return;
			}
			SandSpiderAI val = Resources.FindObjectsOfTypeAll<SandSpiderAI>()[0];
			GameObject gameObject = ((Component)val).gameObject;
			GameObject val2 = null;
			if ((Object)(object)spoderRef == (Object)null)
			{
				val2 = (spoderRef = Object.Instantiate<GameObject>(gameObject, zero, rotation, new GameObject().transform));
				if (Object.op_Implicit((Object)(object)val2.GetComponentInChildren<NetworkObject>()))
				{
					val2.GetComponentInChildren<NetworkObject>().Spawn(true);
				}
				val2.gameObject.SetActive(true);
			}
			else
			{
				val2 = spoderRef;
			}
			spoderRef = val2;
			SandSpiderAI component = val2.GetComponent<SandSpiderAI>();
			component.SpawnWebTrapClientRpc(zero, zero + new Vector3((float)(25.0 - EntropyEngine.rnd.NextDouble() * 50.0), zero.y, (float)(25.0 - EntropyEngine.rnd.NextDouble() * 50.0)));
		}

		public static void miniMan(GameObject target)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: squish");
			GameObject val = nearestPlayerToCoord(target.transform.position);
			PlayerControllerB component = val.GetComponent<PlayerControllerB>();
			Plugin.rpcCalls.squishClientRpc(((NetworkBehaviour)component).NetworkObjectId);
		}

		public static void amogus(GameObject target)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = nearestPlayerToCoord(target.transform.position);
			PlayerControllerB component = val.GetComponent<PlayerControllerB>();
			Plugin.rpcCalls.startAmogusClientRpc(((NetworkBehaviour)component).NetworkObjectId);
		}

		public void eggExplosion(GameObject target, bool targetIsPlayer)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: Egg Bomb Trigger");
			Vector3 zero = Vector3.zero;
			if (targetIsPlayer)
			{
				zero = safeRandomizedPositionFlex(target, 8f * Accumulators.explosionSafetyMult + 5f, 30f, 0);
				Accumulators.explosionSafetyMult *= 0.9f;
			}
			else
			{
				zero = target.transform.position;
			}
			if (zero != Vector3.zero)
			{
				Plugin.rpcCalls.spawnExplosionClientRpc(zero);
			}
		}

		public static void newEventOfDoom(EntropyHost host)
		{
			if (!(EntropyEngine.rnd.NextDouble() > 0.75))
			{
				Plugin.rpcCalls.newRandomEventWarningClientRpc(1 + Accumulators.outcomeCounter);
				for (int i = 0; i < 1 + Accumulators.outcomeCounter; i++)
				{
					host.addRandomOutcome();
				}
				if (Accumulators.outcomeCounter > 5)
				{
					Accumulators.outcomeCounter = 1;
				}
				if (EntropyEngine.rnd.NextDouble() > 0.5)
				{
					Accumulators.outcomeCounter++;
				}
			}
		}

		public static async void obunga(GameObject target, bool targetIsPlayer)
		{
			Debug.Log((object)"Lethal Chaos: Obunga has arrived.");
			_ = Vector3.zero;
			Vector3 position = safeRandomizedPositionFlex(target, 22f, 50f, 0);
			if (position == Vector3.zero)
			{
				return;
			}
			TestEnemy[] allEnemies = Resources.FindObjectsOfTypeAll<TestEnemy>();
			GameObject obunga = null;
			try
			{
				TestEnemy[] array = allEnemies;
				foreach (TestEnemy enemy in array)
				{
					if (!((Object)(object)enemy == (Object)null))
					{
						GameObject go = ((Component)enemy).gameObject;
						Debug.Log((object)go);
						if ((Object)(object)go != (Object)null && ((Object)go).name.ToLower().Contains("capsule"))
						{
							GameObject gameObject = Object.Instantiate<GameObject>(go, position, Quaternion.Euler(Vector3.zero));
							gameObject.gameObject.GetComponentInChildren<NetworkObject>().Spawn(true);
							NavMeshAgent agent = gameObject.GetComponent<EnemyAI>().agent;
							agent.speed /= 1.5f;
							RoundManager.Instance.SpawnedEnemies.Add(gameObject.GetComponent<EnemyAI>());
							EntityDestructionManager.destroyOnLeave.Add(gameObject);
							Accumulators.enemySpawnMult *= 0.95f;
							Plugin.rpcCalls.notifyObungaClientRpc();
							obunga = gameObject;
							break;
						}
					}
				}
			}
			catch (Exception ex)
			{
				Exception e = ex;
				Debug.LogError((object)e);
			}
			await Task.Delay(EntropyEngine.rnd.Next() * 30000);
			if (Object.op_Implicit((Object)(object)obunga))
			{
				Object.Destroy((Object)(object)obunga);
				Plugin.rpcCalls.notifyObungaLeftClientRpc();
			}
			else
			{
				EventThrottler.summons -= 1f;
				EventThrottler.triggerTotals[1]--;
			}
		}

		public static void missileSilo(GameObject target, bool targetIsPlayer)
		{
			Debug.Log((object)"Lethal Chaos: Random missile silo");
			fireMissileSilo(target, targetIsPlayer);
		}

		public static void meteorShower()
		{
			if (!meteorsToday)
			{
				RoundManager instance = RoundManager.Instance;
				GameObject val = GameObject.Find("TimeAndWeather");
				TimeOfDay component = val.GetComponent<TimeOfDay>();
				component.MeteorWeather.SetStartMeteorShower();
				meteorsToday = true;
			}
		}

		public static void picklefyNearbyTextures(GameObject target, bool targetIsPlayer)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: Picklefy Textures");
			Vector3 zero = Vector3.zero;
			zero = safeRandomizedPositionFlex(target, 1f, 5f, 0);
			Plugin.rpcCalls.picklefyClientRpc(zero);
		}

		public static void freeMoney()
		{
			int groupCredits = Object.FindObjectOfType<Terminal>().groupCredits;
			Plugin.rpcCalls.setCreditsClientRpc((int)((float)groupCredits + (float)groupCredits * 0.1f + 5f));
		}

		public static void bigBoi(GameObject target, bool targetIsPlayer)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"Lethal Chaos: big boi");
			GameObject val = nearestPlayerToCoord(target.transform.position);
			PlayerControllerB component = val.GetComponent<PlayerControllerB>();
			Plugin.rpcCalls.expandClientRpc(((NetworkBehaviour)component).NetworkObjectId);
		}

		public static void completelyRandomSound(GameObject target, bool targetIsPlayer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			Vector3 zero = Vector3.zero;
			if (targetIsPlayer)
			{
				zero = safeRandomizedPositionFlex(target, 0f, 2f, 0);
			}
			else
			{
				zero = target.transform.position;
			}
			Debug.Log((object)"Lethal Chaos: random sound:::");
			GameObject val = nearestPlayerToCoord(target.transform.position);
			AudioClip[] array = Resources.FindObjectsOfTypeAll<AudioClip>();
			AudioClip val2 = array[EntropyEngine.rnd.Next(0, array.Length)];
			if (Object.op_Implicit((Object)(object)val2))
			{
				Plugin.rpcCalls.completelyRandomSoundClientRpc(((Object)val2).name, val.transform.position);
			}
		}

		public static Quaternion randomDownToSideRotationFull()
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			float num = Random.Range(0f, 90f);
			float num2 = Random.Range(0f, 360f);
			float num3 = Mathf.Sin(num * (MathF.PI / 180f)) * Mathf.Cos(num2 * (MathF.PI / 180f));
			float num4 = 0f - Mathf.Cos(num * (MathF.PI / 180f));
			float num5 = Mathf.Sin(num * (MathF.PI / 180f)) * Mathf.Sin(num2 * (MathF.PI / 180f));
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(num3, num4, num5);
			Quaternion val2 = Quaternion.LookRotation(((Vector3)(ref val)).normalized, Vector3.up);
			float num6 = Random.Range(0f, 360f);
			Quaternion val3 = Quaternion.AngleAxis(num6, ((Vector3)(ref val)).normalized);
			return val3 * val2;
		}

		private static async void fireMissileSilo(GameObject target, bool targetIsPlayer)
		{
			Debug.Log((object)"Lethal Chaos: Missile Silo");
			int delay = 400;
			int amount = EntropyEngine.rnd.Next(1, 15);
			_ = Vector3.zero;
			Vector3 position = ((!targetIsPlayer) ? target.transform.position : safeRandomizedPositionFlex(target, 0f, 2f, 0));
			if (targetIsPlayer)
			{
				position.y += (float)EntropyEngine.rnd.NextDouble() * 20f + 13f;
			}
			else
			{
				position.y += (float)EntropyEngine.rnd.NextDouble() * 25f;
			}
			for (int i = 0; i < amount; i++)
			{
				Plugin.rpcCalls.makeMissileClientRpc(position, randomDownToSideRotationFull());
				await Task.Delay(delay);
			}
		}

		public static void triggerMostInteractables(GameObject target, bool targetIsPlayer)
		{
			InteractTrigger[] array = Object.FindObjectsOfType<InteractTrigger>();
			foreach (InteractTrigger val in array)
			{
				if ((float)EntropyEngine.rnd.Next() > 0.5f)
				{
					val.Interact(target.transform);
				}
			}
		}

		public static void randomToggleWeather()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			Debug.Log((object)"Lethal Chaos: random toggle weather");
			RoundManager instance = RoundManager.Instance;
			GameObject val = GameObject.Find("TimeAndWeather");
			TimeOfDay component = val.GetComponent<TimeOfDay>();
			List<GameObject> list = new List<GameObject>();
			foreach (Transform item in val.transform)
			{
				Transform val2 = item;
				GameObject gameObject = ((Component)val2).gameObject;
				Debug.Log((object)("Child: " + ((Object)gameObject).name));
				if (!((Object)gameObject).name.ToLower().Contains("meteor") && !((Object)gameObject).name.ToLower().Contains("time"))
				{
					list.Add(gameObject);
				}
			}
			GameObject val3 = list[EntropyEngine.rnd.Next(0, list.Count)];
			if (Object.op_Implicit((Object)(object)val3))
			{
				Plugin.rpcCalls.toggleWeatherClientRpc(((Object)val3).name);
			}
		}

		public static void pufferCloud(GameObject target, bool targetIsPlayer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			Vector3 zero = Vector3.zero;
			zero = safeRandomizedPositionFlex(target, 0f, 26f, 0);
			if (!(zero == Vector3.zero))
			{
				Plugin.rpcCalls.pufferClientRpc(zero);
			}
		}

		public static void shipStreeeeeeeetch()
		{
			Debug.Log((object)"Lethal Chaos: ship streeeeeeeeeeeetch");
			GameObject val = GameObject.Find("HangarShip");
			if (Object.op_Implicit((Object)(object)val))
			{
				int code = EntropyEngine.rnd.Next(0, 3);
				int time = EntropyEngine.rnd.Next(100, 60000);
				Plugin.rpcCalls.shipStretchClientRpc(code, time);
			}
			else
			{
				Debug.LogError((object)"Lethal Chaos: Can't find ship to stretch!");
			}
		}
	}
	internal class EntropyEngine
	{
		public static Random rnd = new Random();

		public static bool SimultaneousOutcomes = false;

		public static float EventHookMultiplier = 1f;

		public static float EventChanceMultiplier = 1f;

		public static float EventChanceOffset = 0f;

		public static EntropyHost entropyHost;

		public static LightningHook lightninghook;

		public static ItemHooks itemhooks;

		public static PlayerHooks playerhooks;

		public static EnemyHooks enemyhooks;

		public static ClockHook modifierhook;

		public static PlanetResetHook resetHooks;

		public static EntityDestructionManager destructionManager = new EntityDestructionManager();

		public static SelectableLevel[] moons = (SelectableLevel[])(object)new SelectableLevel[0];

		public static List<EntropyHost> hosts = new List<EntropyHost>();

		public EntropyEngine()
		{
			Hooks();
		}

		public static void LaunchEngine()
		{
			Debug.Log((object)"Lethal Chaos: Launching Entropy Engine...");
			hosts.Clear();
			int num = Math.Max(0, StartOfRound.Instance.gameStats.daysSpent);
			Debug.Log((object)("LethalChaos: Chaos Engine day count: " + num));
			EventHookMultiplier = Plugin.levelOfChaos.Value + Plugin.levelOfChaosScaling.Value * (float)num;
			EventChanceMultiplier = Plugin.randomOutcomeMultiplier.Value + Plugin.outcomeMultScaling.Value * (float)num;
			Debug.Log((object)("EventHookMultiplier " + EventHookMultiplier));
			Debug.Log((object)("EventChanceMultiplier  " + EventChanceMultiplier));
			if (moons.Length == 0)
			{
				moons = Resources.FindObjectsOfTypeAll(typeof(SelectableLevel)) as SelectableLevel[];
			}
			for (int i = 0; i < moons.Length; i++)
			{
				hosts.Add(new EntropyHost(moons[i].PlanetName));
			}
		}

		public static EntropyHost getMoonHost()
		{
			RoundManager instance = RoundManager.Instance;
			string planetName = instance.currentLevel.PlanetName;
			for (int i = 0; i < moons.Length; i++)
			{
				if (planetName.Equals(moons[i].PlanetName))
				{
					return hosts[i];
				}
			}
			Debug.Log((object)"Lethal Chaos: Failed to find planet. Returning None Planet.");
			return new EntropyHost("None");
		}

		public void Hooks()
		{
			lightninghook = new LightningHook();
			itemhooks = new ItemHooks();
			playerhooks = new PlayerHooks();
			enemyhooks = new EnemyHooks();
			modifierhook = new ClockHook();
			resetHooks = new PlanetResetHook();
			WorldModifiers.Hooks();
		}
	}
	public class EntropyHost
	{
		public static int eventTotal = 47;

		private List<Event> events;

		private ItemSubsetRandomizer it_randomizer;

		public string planet;

		public WorldModifiers modifiers = new WorldModifiers();

		private int it_randomizer_seed = EntropyEngine.rnd.Next();

		public EventThrottler throttler = new EventThrottler();

		public EntropyHost(string planet)
		{
			Debug.Log((object)"Lethal Chaos: New Entropy Host Launched.");
			events = new List<Event>();
			for (int i = 0; i < eventTotal; i++)
			{
				Event @event = new Event(i);
				@event.printData(planet);
				this.planet = planet;
				events.Add(@event);
			}
			throttler = new EventThrottler();
		}

		public void queueHook(string hookID, GameObject obj, bool isSelective, bool targetIsPlayer)
		{
			RoundManager instance = RoundManager.Instance;
			if (it_randomizer == null)
			{
				Debug.Log((object)"Lethal Chaos: Starting Up Subset Randomizers For This Planet");
				it_randomizer = new ItemSubsetRandomizer(instance.currentLevel.spawnableScrap, it_randomizer_seed);
			}
			for (int i = 0; i < events.Count; i++)
			{
				Event @event = events[i];
				if (!@event.hooksAttached.Contains(hookID) || !@event.runOutcome(hookID))
				{
					continue;
				}
				if (EntropyEngine.SimultaneousOutcomes)
				{
					for (int j = 0; j < events.Count; j++)
					{
						Event event2 = events[j];
						if (event2.hooksAttached.Contains(hookID))
						{
							runEvent(event2.eventID, obj, isSelective, targetIsPlayer);
						}
					}
				}
				else
				{
					runEvent(events[i].eventID, obj, isSelective, targetIsPlayer);
				}
			}
		}

		public void runEvent(int method, GameObject obj, bool isSelective, bool playerOrigin)
		{
			try
			{
				RoundManager instance = RoundManager.Instance;
				Debug.Log((object)("running event: " + method + " to " + planet));
				if (!GameNetworkManager.Instance.isHostingGame)
				{
					Debug.Log((object)"block: is not hosting... Returning...");
				}
				else if (EntropyEngine.getMoonHost().planet.Equals("None"))
				{
					Debug.Log((object)"block: host is none. Returning...");
				}
				else if (instance.elevatorUp || instance.totalScrapValueInLevel == 0f)
				{
					Debug.Log((object)"block: Elevator is up. Returning...");
				}
				else if (instance.playersManager.allPlayersDead)
				{
					Debug.Log((object)"block: all players dead. Returning...");
				}
				else
				{
					if ((Object)(object)instance.dungeonGenerator == (Object)null)
					{
						return;
					}
					switch (method)
					{
					case 0:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(0, 15, 0f, 0f))
							{
								return;
							}
							entropyBlaster.bomb(obj, playerOrigin);
						}
						break;
					case 1:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(1, 4, 0f, 1f))
							{
								return;
							}
							entropyBlaster.SpawnRandomOutsideEnemyNear(obj, playerOrigin);
						}
						break;
					case 2:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(2, 12, 0.3f, 0.7f))
							{
								return;
							}
							entropyBlaster.spawnRandomHazard(obj, playerOrigin);
						}
						break;
					case 3:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(3, 10, 0f, 1f))
							{
								return;
							}
							entropyBlaster.spawnTurret(obj, playerOrigin);
						}
						break;
					case 4:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(4, 40, 1f, 0f))
							{
								return;
							}
							entropyBlaster.spawnMine(obj, playerOrigin);
						}
						break;
					case 5:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(5, 4, 0f, 1f))
							{
								return;
							}
							entropyBlaster.SpawnRandomInsideEnemyNear(obj, playerOrigin);
						}
						break;
					case 6:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(6, 10, 0f, 1f))
							{
								return;
							}
							entropyBlaster.spawnHive(obj, playerOrigin);
						}
						break;
					case 7:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(7, 30, 1f, 0f))
							{
								return;
							}
							entropyBlaster.spawnRandomPropOutside(obj, playerOrigin);
						}
						break;
					case 8:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(8, 30, 1f, 0f))
							{
								return;
							}
							entropyBlaster.spawnRandomPropInside(obj, playerOrigin);
						}
						break;
					case 9:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(9, 10, 1f, 0f))
							{
								return;
							}
							entropyBlaster.spawnRandomItem(obj, it_randomizer.provideItemID(), playerOrigin);
						}
						break;
					case 10:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(10, 10, 0f, 0f))
							{
								return;
							}
							entropyBlaster.teleportPlayer(obj, playerOrigin);
						}
						break;
					case 11:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(11, 15, 0f, 0f))
							{
								return;
							}
							entropyBlaster.LBolt(obj, playerOrigin);
						}
						break;
					case 12:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(12, 8, 0f, 0f))
							{
								return;
							}
							entropyBlaster.drunk(obj, playerOrigin);
						}
						break;
					case 13:
						if (EntropyEngine.getMoonHost().throttler.throttleGate(13, 50, 0f, 0f))
						{
							return;
						}
						entropyBlaster.lightFlicker();
						break;
					case 14:
						if (EntropyEngine.getMoonHost().throttler.throttleGate(14, 1000, 0f, 0f))
						{
							return;
						}
						entropyBlaster.timeJumpForward();
						break;
					case 15:
						if (EntropyEngine.getMoonHost().throttler.throttleGate(15, 30, 0f, 0f))
						{
							return;
						}
						entropyBlaster.timeJumpBackward();
						break;
					case 16:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(16, 15, 1f, 0f))
							{
								return;
							}
							entropyBlaster.qsand(obj, playerOrigin);
						}
						break;
					case 17:
						if (EntropyEngine.getMoonHost().throttler.throttleGate(17, 15, 0f, 0f))
						{
							return;
						}
						entropyBlaster.playSoundInsane(obj, playerOrigin);
						break;
					case 18:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(18, 15, 0f, 0f))
							{
								return;
							}
							entropyBlaster.indoorJumpscare(obj, playerOrigin);
						}
						break;
					case 19:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(19, 15, 0f, 0f))
							{
								return;
							}
							entropyBlaster.wormFromHell(obj, playerOrigin);
						}
						break;
					case 20:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(20, 40, 0f, 0f))
							{
								return;
							}
							entropyBlaster.funnyLadder(obj, playerOrigin);
						}
						break;
					case 21:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(21, 30, 0f, 0f))
							{
								return;
							}
							entropyBlaster.fard(obj, playerOrigin);
						}
						break;
					case 22:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(22, 10, 0f, 0f))
							{
								return;
							}
							entropyBlaster.stunPlayer(obj, playerOrigin);
						}
						break;
					case 23:
						if (EntropyEngine.getMoonHost().throttler.throttleGate(23, 100, 0f, 0f))
						{
							return;
						}
						Plugin.rpcCalls.glitchHudClientRpc();
						break;
					case 24:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(24, 20, 0f, 0f))
							{
								return;
							}
							Plugin.rpcCalls.shakeScreenClientRpc();
						}
						break;
					case 25:
						if (EntropyEngine.getMoonHost().throttler.throttleGate(25, 10, 0f, 0f))
						{
							return;
						}
						Plugin.rpcCalls.radiationWarningHudClientRpc();
						break;
					case 26:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(26, 10, 3f, 0f))
							{
								return;
							}
							entropyBlaster.spawnCar(obj, playerOrigin);
						}
						break;
					case 27:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(27, 15, 1f, 0f))
							{
								return;
							}
							entropyBlaster.funnyRadio(obj, playerOrigin);
						}
						break;
					case 28:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(28, 10, 0f, 0f))
							{
								return;
							}
							entropyBlaster.bigBalls(obj, playerOrigin);
						}
						break;
					case 29:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(29, 1, 0f, 0f))
							{
								return;
							}
							entropyBlaster.pong(obj, playerOrigin);
						}
						break;
					case 30:
						if (EntropyEngine.getMoonHost().throttler.throttleGate(30, 1, 0f, 0f))
						{
							return;
						}
						entropyBlaster.newEventOfDoom(this);
						break;
					case 31:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(31, 30, 1f, 0f))
							{
								return;
							}
							entropyBlaster.spawnWeb(obj, playerOrigin);
						}
						break;
					case 32:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(32, 30, 0f, 0f))
							{
								return;
							}
							entropyBlaster.burp(obj, playerOrigin);
						}
						break;
					case 33:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(33, 10, 0f, 0f))
							{
								return;
							}
							entropyBlaster.miniMan(obj);
						}
						break;
					case 34:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(34, 10, 0f, 0f))
							{
								return;
							}
							entropyBlaster.amogus(obj);
						}
						break;
					case 35:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(35, 1, 0f, 0f))
							{
								return;
							}
							entropyBlaster.meds(obj, targetIsPlayer: true);
						}
						break;
					case 36:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(36, 1, 0f, 3f))
							{
								return;
							}
							entropyBlaster.obunga(obj, targetIsPlayer: true);
						}
						break;
					case 37:
						if (EntropyEngine.getMoonHost().throttler.throttleGate(37, 1, 0f, 0f))
						{
							return;
						}
						entropyBlaster.meteorShower();
						break;
					case 38:
						if (EntropyEngine.getMoonHost().throttler.throttleGate(38, 6, 0f, 0f))
						{
							return;
						}
						entropyBlaster.freeMoney();
						break;
					case 39:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(39, 30, 0f, 0f))
							{
								return;
							}
							entropyBlaster.picklefyNearbyTextures(obj, targetIsPlayer: true);
						}
						break;
					case 40:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(40, 9, 0f, 0f))
							{
								return;
							}
							entropyBlaster.bigBoi(obj, targetIsPlayer: true);
						}
						break;
					case 41:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(41, 30, 0f, 0f))
							{
								return;
							}
							entropyBlaster.completelyRandomSound(obj, targetIsPlayer: true);
						}
						break;
					case 42:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(42, 12, 0f, 0f))
							{
								return;
							}
							entropyBlaster.missileSilo(obj, targetIsPlayer: true);
						}
						break;
					case 43:
						if (EntropyEngine.getMoonHost().throttler.throttleGate(43, 2, 0f, 0f))
						{
							return;
						}
						entropyBlaster.shipSuck();
						break;
					case 44:
						if (EntropyEngine.getMoonHost().throttler.throttleGate(44, 0, 0f, 0f))
						{
							return;
						}
						entropyBlaster.randomToggleWeather();
						break;
					case 45:
						if (EntropyEngine.getMoonHost().throttler.throttleGate(45, 1, 0f, 0f))
						{
							return;
						}
						entropyBlaster.shipStreeeeeeeetch();
						break;
					case 46:
						if (isSelective)
						{
							if (EntropyEngine.getMoonHost().throttler.throttleGate(46, 20, 0f, 0f))
							{
								return;
							}
							entropyBlaster.pufferCloud(obj, targetIsPlayer: true);
						}
						break;
					}
					Object.Destroy((Object)(object)obj);
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Lethal Chaos: " + ex.ToString()));
				try
				{
					Object.Destroy((Object)(object)obj);
				}
				catch (Exception)
				{
				}
			}
		}

		public void addRandomOutcome()
		{
			Random random = new Random();
			int index = random.Next(0, events.Count);
			Event @event = events[index];
			int num = random.Next(0, @event.availableHooks.Length);
			@event.hooksAttached.Add(@event.availableHooks[num]);
			double num2 = random.NextDouble();
			double num3 = random.NextDouble();
			double num4 = random.NextDouble();
			double num5 = random.NextDouble() + @event.implicitWeights[num];
			@event.hookChances.Add(100.0 * num2 * num3 * num4 * num5);
		}
	}
	internal class Event
	{
		public int eventID;

		public string[] availableHooks = new string[26]
		{
			"LightningBoltTargeted", "GrabItem", "PlayerHurt", "PlayerLand", "ChargeBatteries", "Teleport", "KillEnemy", "HitEnemy", "PlayerCrouch", "ClockIn",
			"ClockOut", "SwitchItem", "PlayerDeath", "Sprint", "DogInvestigate", "DogRage", "UnlockDoor", "PlayerUnderWater", "GiantEat", "GiantGrab",
			"BugDrop", "BeeZap", "LocustLeave", "MineExplode", "TurretOn", "WebTrip"
		};

		public double[] implicitWeights = new double[26]
		{
			2.0, 1.0, 1.5, 1.1, 4.0, 10.0, 10.0, 2.0, 2.0, 0.002,
			0.002, 1.0, 1000.0, 1.0, 1.5, 4.0, 10.0, 1.4, 100.0, 100.0,
			1.0, 1.0, 1.4, 1000.0, 1.0, 1000.0
		};

		public List<string> hooksAttached = new List<string>();

		public List<double> hookChances = new List<double>();

		private bool forceEvent = false;

		private int forceValue = 28;

		private Random rnd = EntropyEngine.rnd;

		public Event(int eventID)
		{
			this.eventID = eventID;
			double num = 5.0;
			try
			{
				num *= (double)(EntropyEngine.EventHookMultiplier * getUniqueMult(eventID));
			}
			catch
			{
				Debug.LogError((object)"LethalChaos: error parsing EventHookMultiplier setting! Check to see if the setting is a decimal value!");
			}
			for (int i = 0; i < availableHooks.Length; i++)
			{
				double num2 = rnd.NextDouble() * 100.0;
				if (num2 < num)
				{
					hooksAttached.Add(availableHooks[i]);
					double num3 = rnd.NextDouble();
					double num4 = implicitWeights[i];
					float num5 = EntropyEngine.EventChanceMultiplier * getUniqueMult(eventID);
					float eventChanceOffset = EntropyEngine.EventChanceOffset;
					hookChances.Add(Math.Min(Math.Min(100.0 * num3 * num4, 100.0) * (double)num5, 100.0) + (double)eventChanceOffset);
				}
			}
			if (forceEvent && this.eventID == forceValue)
			{
				int num6 = 0;
				try
				{
					num6 = (int)Math.Round(rnd.NextDouble() * (double)availableHooks.Length) - 1;
					hooksAttached.Add(availableHooks[num6]);
				}
				catch
				{
					return;
				}
				double num7 = rnd.NextDouble();
				double num8 = implicitWeights[num6];
				float eventChanceMultiplier = EntropyEngine.EventChanceMultiplier;
				float eventChanceOffset2 = EntropyEngine.EventChanceOffset;
				hookChances.Add(Math.Min(Math.Min(100.0 * num7 * num8, 100.0) * (double)eventChanceMultiplier, 100.0) + (double)eventChanceOffset2);
			}
		}

		public static float getUniqueMult(int eventID)
		{
			if (typeof(Plugin).GetField("e" + eventID) != null && typeof(Plugin).GetField("e" + eventID).GetValue(null) is ConfigEntry<float> val)
			{
				return val.Value;
			}
			Debug.LogError((object)"LethalChaos: getUniqueMult Failed. Event Distribution is not working properly!");
			return 1f;
		}

		public bool runOutcome(string hook)
		{
			int num = -1;
			for (int i = 0; i < hooksAttached.Count; i++)
			{
				if (hooksAttached[i].Equals(hook))
				{
					num = i;
					break;
				}
			}
			if (num == -1)
			{
				return false;
			}
			double num2 = hookChances[num];
			return rnd.NextDouble() * 100.0 < num2;
		}

		public void printData(string planet)
		{
			Debug.Log((object)("Data for ID: " + eventID + " :: " + planet));
			Debug.Log((object)"Hooks - ");
			for (int i = 0; i < hooksAttached.Count; i++)
			{
				Debug.Log((object)("-> " + hooksAttached[i] + "  -- Chance: " + hookChances[i]));
			}
		}
	}
	public class EnemyHooks
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_KillEnemy <>9__0_0;

			public static hook_HitEnemy <>9__0_1;

			public static hook_SearchForPreviouslyHeardSound <>9__0_2;

			public static hook_EnrageDogOnLocalClient <>9__0_3;

			public static hook_GrabPlayerServerRpc <>9__0_4;

			public static hook_BeginEatPlayer <>9__0_5;

			public static hook_DropItem <>9__0_6;

			public static hook_BeesZap <>9__0_7;

			public static hook_bugsLeave <>9__0_8;

			public static hook_ExplodeMineServerRpc <>9__0_9;

			public static hook_ToggleTurretEnabled <>9__0_10;

			public static hook_PlayerTripWebServerRpc <>9__0_11;

			internal void <.ctor>b__0_0(orig_KillEnemy orig, EnemyAI self, bool destroy)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Expected O, but got Unknown
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if (!destroy)
				{
					GameObject val = new GameObject();
					val.transform.position = self.serverPosition;
					orig.Invoke(self, destroy);
					EntropyEngine.getMoonHost().queueHook("KillEnemy", val, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val);
				}
			}

			internal void <.ctor>b__0_1(orig_HitEnemy orig, EnemyAI self, int force, PlayerControllerB playerWhoHit, bool playHitSFX, int hitID)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Expected O, but got Unknown
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, force, playerWhoHit, playHitSFX, hitID);
				GameObject val = new GameObject();
				val.transform.position = self.serverPosition;
				EntropyEngine.getMoonHost().queueHook("HitEnemy", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__0_2(orig_SearchForPreviouslyHeardSound orig, MouthDogAI self)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Expected O, but got Unknown
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				GameObject val = new GameObject();
				val.transform.position = ((EnemyAI)self).serverPosition;
				EntropyEngine.getMoonHost().queueHook("DogInvestigate", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__0_3(orig_EnrageDogOnLocalClient orig, MouthDogAI self, Vector3 targetPosition, float distanceToNoise, bool approximatePosition, bool fullyEnrage)
			{
				//IL_0003: 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_0016: Expected O, but got Unknown
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, targetPosition, distanceToNoise, approximatePosition, fullyEnrage);
				GameObject val = new GameObject();
				val.transform.position = ((EnemyAI)self).serverPosition;
				EntropyEngine.getMoonHost().queueHook("DogRage", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__0_4(orig_GrabPlayerServerRpc orig, ForestGiantAI self, int playerId)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Expected O, but got Unknown
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, playerId);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("GiantGrab", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__0_5(orig_BeginEatPlayer orig, ForestGiantAI self, PlayerControllerB playerBeingEaten, Vector3 enemyPosition, int enemyYRot)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Expected O, but got Unknown
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, playerBeingEaten, enemyPosition, enemyYRot);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("GiantEat", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__0_6(orig_DropItem orig, HoarderBugAI self, NetworkObject item, Vector3 targetFloorPosition, bool droppingInNest)
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Expected O, but got Unknown
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, item, targetFloorPosition, droppingInNest);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("BugDrop", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__0_7(orig_BeesZap orig, RedLocustBees self)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Expected O, but got Unknown
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("BeeZap", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal IEnumerator <.ctor>b__0_8(orig_bugsLeave orig, DocileLocustBeesAI self)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					GameObject val = new GameObject();
					val.transform.position = ((Component)self).transform.position;
					EntropyEngine.getMoonHost().queueHook("LocustLeave", val, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val);
				}
				catch (Exception ex)
				{
					Debug.LogException(ex);
				}
				return orig.Invoke(self);
			}

			internal void <.ctor>b__0_9(orig_ExplodeMineServerRpc orig, Landmine self)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Expected O, but got Unknown
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("MineExplode", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__0_10(orig_ToggleTurretEnabled orig, Turret self, bool enabled)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Expected O, but got Unknown
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, enabled);
				if (enabled)
				{
					GameObject val = new GameObject();
					val.transform.position = ((Component)self).transform.position;
					EntropyEngine.getMoonHost().queueHook("TurretOn", val, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val);
				}
			}

			internal void <.ctor>b__0_11(orig_PlayerTripWebServerRpc orig, SandSpiderAI self, int trapID, int playerNum)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("WebTrip", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}
		}

		public EnemyHooks()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Expected O, but got Unknown
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Expected O, but got Unknown
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Expected O, but got Unknown
			Debug.Log((object)"Lethal Chaos: Hooking Enemy Interactions...");
			try
			{
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					hook_KillEnemy val = delegate(orig_KillEnemy orig, EnemyAI self, bool destroy)
					{
						//IL_000a: Unknown result type (might be due to invalid IL or missing references)
						//IL_0010: Expected O, but got Unknown
						//IL_0017: Unknown result type (might be due to invalid IL or missing references)
						if (!destroy)
						{
							GameObject val24 = new GameObject();
							val24.transform.position = self.serverPosition;
							orig.Invoke(self, destroy);
							EntropyEngine.getMoonHost().queueHook("KillEnemy", val24, isSelective: true, targetIsPlayer: true);
							Object.Destroy((Object)(object)val24);
						}
					};
					<>c.<>9__0_0 = val;
					obj = (object)val;
				}
				EnemyAI.KillEnemy += (hook_KillEnemy)obj;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)ex);
			}
			try
			{
				object obj2 = <>c.<>9__0_1;
				if (obj2 == null)
				{
					hook_HitEnemy val2 = delegate(orig_HitEnemy orig, EnemyAI self, int force, PlayerControllerB playerWhoHit, bool playHitSFX, int hitID)
					{
						//IL_0010: Unknown result type (might be due to invalid IL or missing references)
						//IL_0016: Expected O, but got Unknown
						//IL_001d: Unknown result type (might be due to invalid IL or missing references)
						orig.Invoke(self, force, playerWhoHit, playHitSFX, hitID);
						GameObject val23 = new GameObject();
						val23.transform.position = self.serverPosition;
						EntropyEngine.getMoonHost().queueHook("HitEnemy", val23, isSelective: true, targetIsPlayer: true);
						Object.Destroy((Object)(object)val23);
					};
					<>c.<>9__0_1 = val2;
					obj2 = (object)val2;
				}
				EnemyAI.HitEnemy += (hook_HitEnemy)obj2;
			}
			catch (Exception ex2)
			{
				Debug.LogError((object)ex2);
			}
			try
			{
				object obj3 = <>c.<>9__0_2;
				if (obj3 == null)
				{
					hook_SearchForPreviouslyHeardSound val3 = delegate(orig_SearchForPreviouslyHeardSound orig, MouthDogAI self)
					{
						//IL_0009: Unknown result type (might be due to invalid IL or missing references)
						//IL_000f: Expected O, but got Unknown
						//IL_0016: Unknown result type (might be due to invalid IL or missing references)
						orig.Invoke(self);
						GameObject val22 = new GameObject();
						val22.transform.position = ((EnemyAI)self).serverPosition;
						EntropyEngine.getMoonHost().queueHook("DogInvestigate", val22, isSelective: true, targetIsPlayer: true);
						Object.Destroy((Object)(object)val22);
					};
					<>c.<>9__0_2 = val3;
					obj3 = (object)val3;
				}
				MouthDogAI.SearchForPreviouslyHeardSound += (hook_SearchForPreviouslyHeardSound)obj3;
			}
			catch (Exception ex3)
			{
				Debug.LogError((object)ex3);
			}
			try
			{
				object obj4 = <>c.<>9__0_3;
				if (obj4 == null)
				{
					hook_EnrageDogOnLocalClient val4 = delegate(orig_EnrageDogOnLocalClient orig, MouthDogAI self, Vector3 targetPosition, float distanceToNoise, bool approximatePosition, bool fullyEnrage)
					{
						//IL_0003: 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_0016: Expected O, but got Unknown
						//IL_001d: Unknown result type (might be due to invalid IL or missing references)
						orig.Invoke(self, targetPosition, distanceToNoise, approximatePosition, fullyEnrage);
						GameObject val21 = new GameObject();
						val21.transform.position = ((EnemyAI)self).serverPosition;
						EntropyEngine.getMoonHost().queueHook("DogRage", val21, isSelective: true, targetIsPlayer: true);
						Object.Destroy((Object)(object)val21);
					};
					<>c.<>9__0_3 = val4;
					obj4 = (object)val4;
				}
				MouthDogAI.EnrageDogOnLocalClient += (hook_EnrageDogOnLocalClient)obj4;
			}
			catch (Exception ex4)
			{
				Debug.LogError((object)ex4);
			}
			try
			{
				object obj5 = <>c.<>9__0_4;
				if (obj5 == null)
				{
					hook_GrabPlayerServerRpc val5 = delegate(orig_GrabPlayerServerRpc orig, ForestGiantAI self, int playerId)
					{
						//IL_000a: Unknown result type (might be due to invalid IL or missing references)
						//IL_0010: Expected O, but got Unknown
						//IL_001c: Unknown result type (might be due to invalid IL or missing references)
						orig.Invoke(self, playerId);
						GameObject val20 = new GameObject();
						val20.transform.position = ((Component)self).transform.position;
						EntropyEngine.getMoonHost().queueHook("GiantGrab", val20, isSelective: true, targetIsPlayer: true);
						Object.Destroy((Object)(object)val20);
					};
					<>c.<>9__0_4 = val5;
					obj5 = (object)val5;
				}
				ForestGiantAI.GrabPlayerServerRpc += (hook_GrabPlayerServerRpc)obj5;
			}
			catch (Exception ex5)
			{
				Debug.LogError((object)ex5);
			}
			try
			{
				object obj6 = <>c.<>9__0_5;
				if (obj6 == null)
				{
					hook_BeginEatPlayer val6 = delegate(orig_BeginEatPlayer orig, ForestGiantAI self, PlayerControllerB playerBeingEaten, Vector3 enemyPosition, int enemyYRot)
					{
						//IL_0004: Unknown result type (might be due to invalid IL or missing references)
						//IL_000e: Unknown result type (might be due to invalid IL or missing references)
						//IL_0014: Expected O, but got Unknown
						//IL_0020: Unknown result type (might be due to invalid IL or missing references)
						orig.Invoke(self, playerBeingEaten, enemyPosition, enemyYRot);
						GameObject val19 = new GameObject();
						val19.transform.position = ((Component)self).transform.position;
						EntropyEngine.getMoonHost().queueHook("GiantEat", val19, isSelective: true, targetIsPlayer: true);
						Object.Destroy((Object)(object)val19);
					};
					<>c.<>9__0_5 = val6;
					obj6 = (object)val6;
				}
				ForestGiantAI.BeginEatPlayer += (hook_BeginEatPlayer)obj6;
			}
			catch (Exception ex6)
			{
				Debug.LogError((object)ex6);
			}
			try
			{
				object obj7 = <>c.<>9__0_6;
				if (obj7 == null)
				{
					hook_DropItem val7 = delegate(orig_DropItem orig, HoarderBugAI self, NetworkObject item, Vector3 targetFloorPosition, bool droppingInNest)
					{
						//IL_0004: Unknown result type (might be due to invalid IL or missing references)
						//IL_000e: Unknown result type (might be due to invalid IL or missing references)
						//IL_0014: Expected O, but got Unknown
						//IL_0020: Unknown result type (might be due to invalid IL or missing references)
						orig.Invoke(self, item, targetFloorPosition, droppingInNest);
						GameObject val18 = new GameObject();
						val18.transform.position = ((Component)self).transform.position;
						EntropyEngine.getMoonHost().queueHook("BugDrop", val18, isSelective: true, targetIsPlayer: true);
						Object.Destroy((Object)(object)val18);
					};
					<>c.<>9__0_6 = val7;
					obj7 = (object)val7;
				}
				HoarderBugAI.DropItem += (hook_DropItem)obj7;
			}
			catch (Exception ex7)
			{
				Debug.LogError((object)ex7);
			}
			try
			{
				object obj8 = <>c.<>9__0_7;
				if (obj8 == null)
				{
					hook_BeesZap val8 = delegate(orig_BeesZap orig, RedLocustBees self)
					{
						//IL_0009: Unknown result type (might be due to invalid IL or missing references)
						//IL_000f: Expected O, but got Unknown
						//IL_001b: Unknown result type (might be due to invalid IL or missing references)
						orig.Invoke(self);
						GameObject val17 = new GameObject();
						val17.transform.position = ((Component)self).transform.position;
						EntropyEngine.getMoonHost().queueHook("BeeZap", val17, isSelective: true, targetIsPlayer: true);
						Object.Destroy((Object)(object)val17);
					};
					<>c.<>9__0_7 = val8;
					obj8 = (object)val8;
				}
				RedLocustBees.BeesZap += (hook_BeesZap)obj8;
			}
			catch (Exception ex8)
			{
				Debug.LogError((object)ex8);
			}
			try
			{
				object obj9 = <>c.<>9__0_8;
				if (obj9 == null)
				{
					hook_bugsLeave val9 = delegate(orig_bugsLeave orig, DocileLocustBeesAI self)
					{
						//IL_0002: Unknown result type (might be due to invalid IL or missing references)
						//IL_0008: Expected O, but got Unknown
						//IL_0014: Unknown result type (might be due to invalid IL or missing references)
						try
						{
							GameObject val16 = new GameObject();
							val16.transform.position = ((Component)self).transform.position;
							EntropyEngine.getMoonHost().queueHook("LocustLeave", val16, isSelective: true, targetIsPlayer: true);
							Object.Destroy((Object)(object)val16);
						}
						catch (Exception ex13)
						{
							Debug.LogException(ex13);
						}
						return orig.Invoke(self);
					};
					<>c.<>9__0_8 = val9;
					obj9 = (object)val9;
				}
				DocileLocustBeesAI.bugsLeave += (hook_bugsLeave)obj9;
			}
			catch (Exception ex9)
			{
				Debug.LogError((object)ex9);
			}
			try
			{
				object obj10 = <>c.<>9__0_9;
				if (obj10 == null)
				{
					hook_ExplodeMineServerRpc val10 = delegate(orig_ExplodeMineServerRpc orig, Landmine self)
					{
						//IL_0009: Unknown result type (might be due to invalid IL or missing references)
						//IL_000f: Expected O, but got Unknown
						//IL_001b: Unknown result type (might be due to invalid IL or missing references)
						orig.Invoke(self);
						GameObject val15 = new GameObject();
						val15.transform.position = ((Component)self).transform.position;
						EntropyEngine.getMoonHost().queueHook("MineExplode", val15, isSelective: true, targetIsPlayer: true);
						Object.Destroy((Object)(object)val15);
					};
					<>c.<>9__0_9 = val10;
					obj10 = (object)val10;
				}
				Landmine.ExplodeMineServerRpc += (hook_ExplodeMineServerRpc)obj10;
			}
			catch (Exception ex10)
			{
				Debug.LogError((object)ex10);
			}
			try
			{
				object obj11 = <>c.<>9__0_10;
				if (obj11 == null)
				{
					hook_ToggleTurretEnabled val11 = delegate(orig_ToggleTurretEnabled orig, Turret self, bool enabled)
					{
						//IL_0010: Unknown result type (might be due to invalid IL or missing references)
						//IL_0016: Expected O, but got Unknown
						//IL_0022: Unknown result type (might be due to invalid IL or missing references)
						orig.Invoke(self, enabled);
						if (enabled)
						{
							GameObject val14 = new GameObject();
							val14.transform.position = ((Component)self).transform.position;
							EntropyEngine.getMoonHost().queueHook("TurretOn", val14, isSelective: true, targetIsPlayer: true);
							Object.Destroy((Object)(object)val14);
						}
					};
					<>c.<>9__0_10 = val11;
					obj11 = (object)val11;
				}
				Turret.ToggleTurretEnabled += (hook_ToggleTurretEnabled)obj11;
			}
			catch (Exception ex11)
			{
				Debug.LogError((object)ex11);
			}
			try
			{
				object obj12 = <>c.<>9__0_11;
				if (obj12 == null)
				{
					hook_PlayerTripWebServerRpc val12 = delegate(orig_PlayerTripWebServerRpc orig, SandSpiderAI self, int trapID, int playerNum)
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						//IL_0007: Expected O, but got Unknown
						//IL_0013: Unknown result type (might be due to invalid IL or missing references)
						GameObject val13 = new GameObject();
						val13.transform.position = ((Component)self).transform.position;
						EntropyEngine.getMoonHost().queueHook("WebTrip", val13, isSelective: true, targetIsPlayer: true);
						Object.Destroy((Object)(object)val13);
					};
					<>c.<>9__0_11 = val12;
					obj12 = (object)val12;
				}
				SandSpiderAI.PlayerTripWebServerRpc += (hook_PlayerTripWebServerRpc)obj12;
			}
			catch (Exception ex12)
			{
				Debug.LogError((object)ex12);
			}
		}
	}
	public class ItemHooks
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_GrabServerRpc <>9__0_0;

			public static hook_ChargeBatteries <>9__0_1;

			internal void <.ctor>b__0_0(orig_GrabServerRpc orig, GrabbableObject self)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Expected O, but got Unknown
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("GrabItem", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__0_1(orig_ChargeBatteries orig, GrabbableObject self)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Expected O, but got Unknown
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("ChargeBatteries", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}
		}

		public ItemHooks()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			Debug.Log((object)"Lethal Chaos: Hooking Items...");
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				hook_GrabServerRpc val = delegate(orig_GrabServerRpc orig, GrabbableObject self)
				{
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Expected O, but got Unknown
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					GameObject val4 = new GameObject();
					val4.transform.position = ((Component)self).transform.position;
					EntropyEngine.getMoonHost().queueHook("GrabItem", val4, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val4);
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			GrabbableObject.GrabServerRpc += (hook_GrabServerRpc)obj;
			object obj2 = <>c.<>9__0_1;
			if (obj2 == null)
			{
				hook_ChargeBatteries val2 = delegate(orig_ChargeBatteries orig, GrabbableObject self)
				{
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Expected O, but got Unknown
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					GameObject val3 = new GameObject();
					val3.transform.position = ((Component)self).transform.position;
					EntropyEngine.getMoonHost().queueHook("ChargeBatteries", val3, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val3);
				};
				<>c.<>9__0_1 = val2;
				obj2 = (object)val2;
			}
			GrabbableObject.ChargeBatteries += (hook_ChargeBatteries)obj2;
		}
	}
	public class LightningHook
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_LightningStrike <>9__0_0;

			internal void <.ctor>b__0_0(orig_LightningStrike orig, StormyWeather self, Vector3 strikePosition, bool useTargetedObject)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, strikePosition, useTargetedObject);
				GameObject val = new GameObject();
				val.transform.position = strikePosition;
				EntropyEngine.getMoonHost().queueHook("LightningBoltTargeted", val, isSelective: true, targetIsPlayer: false);
				Object.Destroy((Object)(object)val);
			}
		}

		public LightningHook()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			Debug.Log((object)"Lethal Chaos: Hooking Lightning Bolts...");
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				hook_LightningStrike val = delegate(orig_LightningStrike orig, StormyWeather self, Vector3 strikePosition, bool useTargetedObject)
				{
					//IL_0003: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: Expected O, but got Unknown
					//IL_0018: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self, strikePosition, useTargetedObject);
					GameObject val2 = new GameObject();
					val2.transform.position = strikePosition;
					EntropyEngine.getMoonHost().queueHook("LightningBoltTargeted", val2, isSelective: true, targetIsPlayer: false);
					Object.Destroy((Object)(object)val2);
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			StormyWeather.LightningStrike += (hook_LightningStrike)obj;
		}
	}
	public class PlayerHooks
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_DamagePlayerServerRpc <>9__1_0;

			public static hook_PlayerJumpedServerRpc <>9__1_1;

			public static hook_Crouch <>9__1_2;

			public static hook_TeleportPlayer <>9__1_3;

			public static hook_SwitchItemSlotsServerRpc <>9__1_4;

			public static hook_PlayFootstepSound <>9__1_5;

			public static hook_LoadNewLevel <>9__1_6;

			public static hook_UnlockDoor <>9__1_7;

			public static hook_SetFaceUnderwaterServerRpc <>9__1_8;

			internal void <.ctor>b__1_0(orig_DamagePlayerServerRpc orig, PlayerControllerB self, int damageNumber, int newHealthAmount)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, damageNumber, newHealthAmount);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("PlayerHurt", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__1_1(orig_PlayerJumpedServerRpc orig, PlayerControllerB self)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Expected O, but got Unknown
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("PlayerLand", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__1_2(orig_Crouch orig, PlayerControllerB self, bool crouch)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Expected O, but got Unknown
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, crouch);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("PlayerCrouch", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__1_3(orig_TeleportPlayer orig, PlayerControllerB self, Vector3 pos, bool withRotation, float rot, bool allowInteractTrigger, bool enableController)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Expected O, but got Unknown
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, pos, withRotation, rot, allowInteractTrigger, enableController);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("Teleport", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__1_4(orig_SwitchItemSlotsServerRpc orig, PlayerControllerB self, bool forward)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Expected O, but got Unknown
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self, forward);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("SwitchItem", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__1_5(orig_PlayFootstepSound orig, PlayerControllerB self)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Expected O, but got Unknown
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				if (!sprintToggle.ContainsKey(self))
				{
					sprintToggle.Add(self, value: false);
				}
				if (self.isSprinting != sprintToggle[self])
				{
					EntropyEngine.getMoonHost().queueHook("Sprint", val, isSelective: true, targetIsPlayer: true);
					sprintToggle[self] = self.isSprinting;
				}
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__1_6(orig_LoadNewLevel orig, RoundManager self, int randomSeed, SelectableLevel newLevel)
			{
				orig.Invoke(self, randomSeed, newLevel);
				if (GameNetworkManager.Instance.isHostingGame)
				{
					sprintToggle = new Dictionary<PlayerControllerB, bool>();
				}
			}

			internal void <.ctor>b__1_7(orig_UnlockDoor orig, DoorLock self)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Expected O, but got Unknown
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("UnlockDoor", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}

			internal void <.ctor>b__1_8(orig_SetFaceUnderwaterServerRpc orig, PlayerControllerB self)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Expected O, but got Unknown
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				orig.Invoke(self);
				GameObject val = new GameObject();
				val.transform.position = ((Component)self).transform.position;
				EntropyEngine.getMoonHost().queueHook("PlayerUnderWater", val, isSelective: true, targetIsPlayer: true);
				Object.Destroy((Object)(object)val);
			}
		}

		public static Dictionary<PlayerControllerB, bool> sprintToggle = new Dictionary<PlayerControllerB, bool>();

		public PlayerHooks()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//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_00a1: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			Debug.Log((object)"Lethal Chaos: Hooking Player Actions...");
			object obj = <>c.<>9__1_0;
			if (obj == null)
			{
				hook_DamagePlayerServerRpc val = delegate(orig_DamagePlayerServerRpc orig, PlayerControllerB self, int damageNumber, int newHealthAmount)
				{
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: Expected O, but got Unknown
					//IL_001e: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self, damageNumber, newHealthAmount);
					GameObject val17 = new GameObject();
					val17.transform.position = ((Component)self).transform.position;
					EntropyEngine.getMoonHost().queueHook("PlayerHurt", val17, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val17);
				};
				<>c.<>9__1_0 = val;
				obj = (object)val;
			}
			PlayerControllerB.DamagePlayerServerRpc += (hook_DamagePlayerServerRpc)obj;
			object obj2 = <>c.<>9__1_1;
			if (obj2 == null)
			{
				hook_PlayerJumpedServerRpc val2 = delegate(orig_PlayerJumpedServerRpc orig, PlayerControllerB self)
				{
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Expected O, but got Unknown
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					GameObject val16 = new GameObject();
					val16.transform.position = ((Component)self).transform.position;
					EntropyEngine.getMoonHost().queueHook("PlayerLand", val16, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val16);
				};
				<>c.<>9__1_1 = val2;
				obj2 = (object)val2;
			}
			PlayerControllerB.PlayerJumpedServerRpc += (hook_PlayerJumpedServerRpc)obj2;
			object obj3 = <>c.<>9__1_2;
			if (obj3 == null)
			{
				hook_Crouch val3 = delegate(orig_Crouch orig, PlayerControllerB self, bool crouch)
				{
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: Expected O, but got Unknown
					//IL_001c: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self, crouch);
					GameObject val15 = new GameObject();
					val15.transform.position = ((Component)self).transform.position;
					EntropyEngine.getMoonHost().queueHook("PlayerCrouch", val15, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val15);
				};
				<>c.<>9__1_2 = val3;
				obj3 = (object)val3;
			}
			PlayerControllerB.Crouch += (hook_Crouch)obj3;
			object obj4 = <>c.<>9__1_3;
			if (obj4 == null)
			{
				hook_TeleportPlayer val4 = delegate(orig_TeleportPlayer orig, PlayerControllerB self, Vector3 pos, bool withRotation, float rot, bool allowInteractTrigger, bool enableController)
				{
					//IL_0003: Unknown result type (might be due to invalid IL or missing references)
					//IL_0012: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Expected O, but got Unknown
					//IL_0024: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self, pos, withRotation, rot, allowInteractTrigger, enableController);
					GameObject val14 = new GameObject();
					val14.transform.position = ((Component)self).transform.position;
					EntropyEngine.getMoonHost().queueHook("Teleport", val14, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val14);
				};
				<>c.<>9__1_3 = val4;
				obj4 = (object)val4;
			}
			PlayerControllerB.TeleportPlayer += (hook_TeleportPlayer)obj4;
			object obj5 = <>c.<>9__1_4;
			if (obj5 == null)
			{
				hook_SwitchItemSlotsServerRpc val5 = delegate(orig_SwitchItemSlotsServerRpc orig, PlayerControllerB self, bool forward)
				{
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: Expected O, but got Unknown
					//IL_001c: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self, forward);
					GameObject val13 = new GameObject();
					val13.transform.position = ((Component)self).transform.position;
					EntropyEngine.getMoonHost().queueHook("SwitchItem", val13, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val13);
				};
				<>c.<>9__1_4 = val5;
				obj5 = (object)val5;
			}
			PlayerControllerB.SwitchItemSlotsServerRpc += (hook_SwitchItemSlotsServerRpc)obj5;
			object obj6 = <>c.<>9__1_5;
			if (obj6 == null)
			{
				hook_PlayFootstepSound val6 = delegate(orig_PlayFootstepSound orig, PlayerControllerB self)
				{
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Expected O, but got Unknown
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					GameObject val12 = new GameObject();
					val12.transform.position = ((Component)self).transform.position;
					if (!sprintToggle.ContainsKey(self))
					{
						sprintToggle.Add(self, value: false);
					}
					if (self.isSprinting != sprintToggle[self])
					{
						EntropyEngine.getMoonHost().queueHook("Sprint", val12, isSelective: true, targetIsPlayer: true);
						sprintToggle[self] = self.isSprinting;
					}
					Object.Destroy((Object)(object)val12);
				};
				<>c.<>9__1_5 = val6;
				obj6 = (object)val6;
			}
			PlayerControllerB.PlayFootstepSound += (hook_PlayFootstepSound)obj6;
			object obj7 = <>c.<>9__1_6;
			if (obj7 == null)
			{
				hook_LoadNewLevel val7 = delegate(orig_LoadNewLevel orig, RoundManager self, int randomSeed, SelectableLevel newLevel)
				{
					orig.Invoke(self, randomSeed, newLevel);
					if (GameNetworkManager.Instance.isHostingGame)
					{
						sprintToggle = new Dictionary<PlayerControllerB, bool>();
					}
				};
				<>c.<>9__1_6 = val7;
				obj7 = (object)val7;
			}
			RoundManager.LoadNewLevel += (hook_LoadNewLevel)obj7;
			object obj8 = <>c.<>9__1_7;
			if (obj8 == null)
			{
				hook_UnlockDoor val8 = delegate(orig_UnlockDoor orig, DoorLock self)
				{
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Expected O, but got Unknown
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					GameObject val11 = new GameObject();
					val11.transform.position = ((Component)self).transform.position;
					EntropyEngine.getMoonHost().queueHook("UnlockDoor", val11, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val11);
				};
				<>c.<>9__1_7 = val8;
				obj8 = (object)val8;
			}
			DoorLock.UnlockDoor += (hook_UnlockDoor)obj8;
			object obj9 = <>c.<>9__1_8;
			if (obj9 == null)
			{
				hook_SetFaceUnderwaterServerRpc val9 = delegate(orig_SetFaceUnderwaterServerRpc orig, PlayerControllerB self)
				{
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_000f: Expected O, but got Unknown
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					orig.Invoke(self);
					GameObject val10 = new GameObject();
					val10.transform.position = ((Component)self).transform.position;
					EntropyEngine.getMoonHost().queueHook("PlayerUnderWater", val10, isSelective: true, targetIsPlayer: true);
					Object.Destroy((Object)(object)val10);
				};
				<>c.<>9__1_8 = val9;
				obj9 = (object)val9;
			}
			PlayerControllerB.SetFaceUnderwaterServerRpc += (hook_SetFaceUnderwaterServerRpc)obj9;
		}
	}
	public class PlayerHooksLocalized
	{
		public static Dictionary<PlayerControllerB, bool> sprintToggle = new Dictionary<PlayerControllerB, bool>();

		public PlayerHooksLocalized()
		{
			Debug.Log((object)"Lethal Chaos: Hooking Player Actions (Localized)...");
		}
	}
}
namespace LethalChaos
{
	[BepInPlugin("LethalChaos", "LethalChaos", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public static class Assets
		{
			public static AssetBundle MainAssetBundle;

			public static AssetBundle PrefabAssetBundle;

			public static void PopulateAssets()
			{
				string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
				MainAssetBundle = AssetBundle.LoadFromFile(Path.Combine(directoryName, "chaosbundle"));
				PrefabAssetBundle = AssetBundle.LoadFromFile(Path.Combine(directoryName, "lethalchaosprefabs"));
				if ((Object)(object)MainAssetBundle == (Object)null)
				{
					Debug.LogError((object)"Failed to load custom assets.");
				}
			}
		}

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

			public static GenericButtonHandler <>9__84_0;

			public static hook_Awake <>9__84_1;

			public static hook_Awake <>9__84_2;

			public static hook_ReactToNoise <>9__84_3;

			public static hook_ReachedNodeInSearch <>9__84_4;

			public static hook_BeginEatPlayer <>9__84_5;

			internal void <bindVars>b__84_0()
			{
				EntropyEngine.EventHookMultiplier = levelOfChaos.Value;
				EntropyEngine.EventChanceMultiplier = randomOutcomeMultiplier.Value;
				EntropyEngine.LaunchEngine();
			}

			internal void <bindVars>b__84_1(orig_Awake orig, MenuManager self)
			{
				if (clevelandBrown.Value)
				{
					self.menuMusic = clevelandBrownMusic;
				}
			}

			internal void <bindVars>b__84_2(orig_Awake orig, ShipTeleporter self)
			{
				if (clevelandBrown.Value)
				{
					self.buttonAudio.clip = clevelandTele;
				}
				orig.Invoke(self);
			}

			internal void <bindVars>b__84_3(orig_ReactToNoise orig, ForestGiantAI self, float distanceToNoise, Vector3 noisePosition)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				if (clevelandBrown.Value)
				{
					self.giantBurningAudio.PlayOneShot(gangnamOP);
				}
				orig.Invoke(self, distanceToNoise, noisePosition);
			}

			internal void <bindVars>b__84_4(orig_ReachedNodeInSearch orig, ForestGiantAI self)
			{
				if (clevelandBrown.Value)
				{
					self.giantBurningAudio.PlayOneShot(gangnamOP);
				}
				orig.Invoke(self);
			}

			internal void <bindVars>b__84_5(orig_BeginEatPlayer orig, ForestGiantAI self, PlayerControllerB playerBeingEaten, Vector3 enemyPosition, int enemyYRot)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				if (clevelandBrown.Value)
				{
					self.giantBurningAudio.PlayOneShot(gangnamStyle);
				}
				orig.Invoke(self, playerBeingEaten, enemyPosition, enemyYRot);
			}
		}

		private EntropyEngine engine;

		public static GameObject ChaosHostRef;

		public static GameObject ChaosHost;

		public static LethalNet rpcCalls;

		public static AudioClip fard1;

		public static AudioClip fard2;

		public static AudioClip fard3;

		public static AudioClip burp1;

		public static AudioClip burp2;

		public static AudioClip burp3;

		public static AudioClip squish;

		public static GameObject Pong;

		public static GameObject Amogus;

		public static AudioClip mogusSound;

		public static AudioClip medkit;

		public static AudioClip expandSound;

		public static AudioClip blastNoise;

		public static AudioClip clevelandBrownMusic;

		public static AudioClip clevelandTele;

		public static AudioClip gangnamOP;

		public static AudioClip gangnamStyle;

		public static Material pickleMaterial;

		public static GameObject missilePrefab;

		public static GameObject pufferCloud;

		public static AudioClip pufferSound;

		internal static InputMap controls;

		public static ConfigEntry<float> levelOfChaos;

		public static ConfigEntry<float> fogChance;

		public static ConfigEntry<float> randomOutcomeMultiplier;

		public static ConfigEntry<float> maxMonsterCount;

		public static ConfigEntry<float> maxObjectCount;

		public static ConfigEntry<bool> allowPong;

		public static ConfigEntry<bool> clevelandBrown;

		public static ConfigEntry<float> levelOfChaosScaling;

		public static ConfigEntry<float> outcomeMultScaling;

		public static ConfigEntry<float> e0;

		public static ConfigEntry<float> e1;

		public static ConfigEntry<float> e2;

		public static ConfigEntry<float> e3;

		public static ConfigEntry<float> e4;

		public static ConfigEntry<float> e5;

		public static ConfigEntry<float> e6;

		public static ConfigEntry<float> e7;

		public static ConfigEntry<float> e8;

		public static ConfigEntry<float> e9;

		public static ConfigEntry<float> e10;

		public static ConfigEntry<float> e11;

		public static ConfigEntry<float> e12;

		public static ConfigEntry<float> e13;

		public static ConfigEntry<float> e14;

		public static ConfigEntry<float> e15;

		public static ConfigEntry<float> e16;

		public static ConfigEntry<float> e17;

		public static ConfigEntry<float> e18;

		public static ConfigEntry<float> e19;

		public static ConfigEntry<float> e20;

		public static ConfigEntry<float> e21;

		public static ConfigEntry<float> e22;

		public static ConfigEntry<float> e23;

		public static ConfigEntry<float> e24;

		public static ConfigEntry<float> e25;

		public static ConfigEntry<float> e26;

		public static ConfigEntry<float> e27;

		public static ConfigEntry<float> e28;

		public static ConfigEntry<float> e29;

		public static ConfigEntry<float> e30;

		public static ConfigEntry<float> e31;

		public static ConfigEntry<float> e32;

		public static ConfigEntry<float> e33;

		public static ConfigEntry<float> e34;

		public static ConfigEntry<float> e35;

		public static ConfigEntry<float> e36;

		public static ConfigEntry<float> e37;

		public static ConfigEntry<float> e38;

		public static ConfigEntry<float> e39;

		public static ConfigEntry<float> e40;

		public static ConfigEntry<float> e41;

		public static ConfigEntry<float> e42;

		public static ConfigEntry<float> e43;

		public static ConfigEntry<float> e44;

		public static ConfigEntry<float> e45;

		public static ConfigEntry<float> e46;

		private void Awake()
		{
			Debug.Log((object)"Lethal Chaos: Loading Network Host...");
			Assets.PopulateAssets();
			bindVars();
			ChaosHostRef = Assets.MainAssetBundle.LoadAsset<GameObject>("ChaosHost");
			fard1 = Assets.MainAssetBundle.LoadAsset<AudioClip>("fart1");
			fard2 = Assets.MainAssetBundle.LoadAsset<AudioClip>("fart2");
			fard3 = Assets.MainAssetBundle.LoadAsset<AudioClip>("fart3");
			burp1 = Assets.MainAssetBundle.LoadAsset<AudioClip>("Burp1");
			burp2 = Assets.MainAssetBundle.LoadAsset<AudioClip>("Burp2");
			burp3 = Assets.MainAssetBundle.LoadAsset<AudioClip>("Burp3");
			squish = Assets.MainAssetBundle.LoadAsset<AudioClip>("squish");
			Pong = Assets.MainAssetBundle.LoadAsset<GameObject>("Pong");
			Amogus = Assets.MainAssetBundle.LoadAsset<GameObject>("Amogus");
			mogusSound = Assets.MainAssetBundle.LoadAsset<AudioClip>("mogus");
			medkit = Assets.MainAssetBundle.LoadAsset<AudioClip>("medkit");
			clevelandBrownMusic = Assets.MainAssetBundle.LoadAsset<AudioClip>("clevelandBrown");
			clevelandTele = Assets.MainAssetBundle.LoadAsset<AudioClip>("clevelandno");
			gangnamOP = Assets.MainAssetBundle.LoadAsset<AudioClip>("OP");
			gangnamStyle = Assets.MainAssetBundle.LoadAsset<AudioClip>("gangnamstyle");
			pickleMaterial = Assets.MainAssetBundle.LoadAsset<Material>("pickleMaterial");
			expandSound = Assets.MainAssetBundle.LoadAsset<AudioClip>("bigboi");
			missilePrefab = Assets.PrefabAssetBundle.LoadAsset<GameObject>("ChaosMissile");
			blastNoise = Assets.MainAssetBundle.LoadAsset<AudioClip>("ShotgunBlast");
			pufferCloud = Assets.PrefabAssetBundle.LoadAsset<GameObject>("Sporecloud");
			pufferSound = Assets.PrefabAssetBundle.LoadAsset<AudioClip>("PuffSFX");
			Debug.Log((object)("Lethal Chaos Asset Bundle: " + ((object)Assets.MainAssetBundle).ToString()));
			Debug.Log((object)("Lethal Chaos Host Obj: " + (object)ChaosHostRef));
			NetworkPrefabs.RegisterNetworkPrefab(ChaosHostRef);
			Debug.Log((object)"Lethal Chaos: Patching Network Methods...");
			Type[] types;
			try
			{
				types = Assembly.GetExecutingAssembly().GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				Debug.LogWarning((object)("Lethal Chaos: ReflectionTypeLoadException during GetTypes(), using partial type list. " + ex.Message));
				types = ex.Types;
			}
			Type[] array = types;
			foreach (Type type in array)
			{
				if (type == null)
				{
					continue;
				}
				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);
					}
				}
			}
			Debug.Log((object)"Lethal Chaos: Creating The Entropy Engine");
			EntropyEngine.EventHookMultiplier = levelOfChaos.Value;
			EntropyEngine.EventChanceMultiplier = randomOutcomeMultiplier.Value;
			engine = new EntropyEngine();
			controls = new InputMap();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Lethal Chaos is loaded!");
		}

		public void bindEvents()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0054: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00af: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Expected O, but got Unknown
			//IL_010a: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			//IL_0165: Expected O, but got Unknown
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected O, but got Unknown
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			//IL_01c0: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Expected O, but got Unknown
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Expected O, but got Unknown
			//IL_021d: Expected O, but got Unknown
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Expected O, but got Unknown
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Expected O, but got Unknown
			//IL_027a: Expected O, but got Unknown
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Expected O, but got Unknown
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Expected O, but got Unknown
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Expected O, but got Unknown
			//IL_02d7: Expected O, but got Unknown
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Expected O, but got Unknown
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Expected O, but got Unknown
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Expected O, but got Unknown
			//IL_0334: Expected O, but got Unknown
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Expected O, but got Unknown
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Expected O, but got Unknown
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Expected O, but got Unknown
			//IL_0391: Expected O, but got Unknown
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Expected O, but got Unknown
			//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Expected O, but got Unknown
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e8: Expected O, but got Unknown
			//IL_03ee: Expected O, but got Unknown
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Expected O, but got Unknown
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Expected O, but got Unknown
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Expected O, but got Unknown
			//IL_044b: Expected O, but got Unknown
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Expected O, but got Unknown
			//IL_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0483: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0496: Expected O, but got Unknown
			//IL_0497: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Expected O, but got Unknown
			//IL_04a8: Expected O, but got Unknown
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Expected O, but got Unknown
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Expected O, but got Unknown
			//IL_04f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Expected O, but got Unknown
			//IL_0505: Expected O, but got Unknown
			//IL_0500: Unknown result type (might be due to invalid IL or missing references)
			//IL_0507: Expected O, but got Unknown
			//IL_0538: Unknown result type (might be due to invalid IL or missing references)
			//IL_053d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0545: Unknown result type (might be due to invalid IL or missing references)
			//IL_0550: Expected O, but got Unknown
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Expected O, but got Unknown
			//IL_0562: Expected O, but got Unknown
			//IL_055d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0564: Expected O, but got Unknown
			//IL_0595: Unknown result type (might be due to invalid IL or missing references)
			//IL_059a: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ad: Expected O, but got Unknown
			//IL_05ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b9: Expected O, but got Unknown
			//IL_05bf: Expected O, but got Unknown
			//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c1: Expected O, but got Unknown
			//IL_05f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_060a: Expected O, but got Unknown
			//IL_060b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0616: Expected O, but got Unknown
			//IL_061c: Expected O, but got Unknown
			//IL_0617: Unknown result type (might be due to invalid IL or missing references)
			//IL_061e: Expected O, but got Unknown
			//IL_064f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0654: Unknown result type (might be due to invalid IL or missing references)
			//IL_065c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0667: Expected O, but got Unknown
			//IL_0668: Unknown result type (might be due to invalid IL or missing references)
			//IL_0673: Expected O, but got Unknown
			//IL_0679: Expected O, but got Unknown
			//IL_0674: Unknown result type (might be due to invalid IL or missing references)
			//IL_067b: Expected O, but got Unknown
			//IL_06ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c4: Expected O, but got Unknown
			//IL_06c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d0: Expected O, but got Unknown
			//IL_06d6: Expected O, but got Unknown
			//IL_06d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d8: Expected O, but got Unknown
			//IL_0709: Unknown result type (might be due to invalid IL or missing references)
			//IL_070e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0716: Unknown result type (might be due to invalid IL or missing references)
			//IL_0721: Expected O, but got Unknown
			//IL_0722: Unknown result type (might be due to invalid IL or missing references)
			//IL_072d: Expected O, but got Unknown
			//IL_0733: Expected O, but got Unknown
			//IL_072e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0735: Expected O, but got Unknown
			//IL_0766: Unknown result type (might be due to invalid IL or missing references)
			//IL_076b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0773: Unknown result type (might be due to invalid IL or missing references)
			//IL_077e: Expected O, but got Unknown
			//IL_077f: Unknown result type (might be due to invalid IL or missing references)
			//IL_078a: Expected O, but got Unknown
			//IL_0790: Expected O, but got Unknown
			//IL_078b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0792: Expected O, but got Unknown
			//IL_07c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07db: Expected O, but got Unknown
			//IL_07dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e7: Expected O, but got Unknown
			//IL_07ed: Expected O, but got Unknown
			//IL_07e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ef: Expected O, but got Unknown
			//IL_0820: Unknown result type (might be due to invalid IL or missing references)
			//IL_0825: Unknown result type (might be due to invalid IL or missing references)
			//IL_082d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0838: Expected O, but got Unknown
			//IL_0839: Unknown result type (might be due to invalid IL or missing references)
			//IL_0844: Expected O, but got Unknown
			//IL_084a: Expected O, but got Unknown
			//IL_0845: Unknown result type (might be due to invalid IL or missing references)
			//IL_084c: Expected O, but got Unknown
			//IL_087d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0882: Unknown result type (might be due to invalid IL or missing references)
			//IL_088a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0895: Expected O, but got Unknown
			//IL_0896: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a1: Expected O, but got Unknown
			//IL_08a7: Expected O, but got Unknown
			//IL_08a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a9: Expected O, but got Unknown
			//IL_08da: Unknown result type (might be due to invalid IL or missing references)
			//IL_08df: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f2: Expected O, but got Unknown
			//IL_08f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fe: Expected O, but got Unknown
			//IL_0904: Expected O, but got Unknown
			//IL_08ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0906: Expected O, but got Unknown
			//IL_0937: Unknown result type (might be due to invalid IL or missing references)
			//IL_093c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0944: Unknown result type (might be due to invalid IL or missing references)
			//IL_094f: Expected O, but got Unknown
			//IL_0950: Unknown result type (might be due to invalid IL or missing references)
			//IL_095b: Expected O, but got Unknown
			//IL_0961: Expected O, but got Unknown
			//IL_095c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0963: Expected O, but got Unknown
			//IL_0994: Unknown result type (might be due to invalid IL or missing references)
			//IL_0999: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ac: Expected O, but got Unknown
			//IL_09ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b8: Expected O, but got Unknown
			//IL_09be: Expected O, but got Unknown
			//IL_09b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c0: Expected O, but got Unknown
			//IL_09f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_09fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a09: Expected O, but got Unknown
			//IL_0a0a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a15: Expected O, but got Unknown
			//IL_0a1b: Expected O, but got Unknown
			//IL_0a16: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a1d: Expected O, but got Unknown
			//IL_0a4e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a53: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a5b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a66: Expected O, but got Unknown
			//IL_0a67: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a72: Expected O, but got Unknown
			//IL_0a78: Expected O, but got Unknown
			//IL_0a73: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a7a: Expected O, but got Unknown
			//IL_0aab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac3: Expected O, but got Unknown
			//IL_0ac4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0acf: Expected O, but got Unknown
			//IL_0ad5: Expected O, but got Unknown
			//IL_0ad0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ad7: Expected O, but got Unknown
			//IL_0b08: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b0d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b15: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b20: Expected O, but got Unknown
			//IL_0b21: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b2c: Expected O, but got Unknown
			//IL_0b32: Expected O, but got Unknown
			//IL_0b2d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b34: Expected O, but got Unknown
			//IL_0b65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b6a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b72: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b7d: Expected O, but got Unknown
			//IL_0b7e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b89: Expected O, but got Unknown
			//IL_0b8f: Expected O, but got Unknown
			//IL_0b8a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b91: Expected O, but got Unknown
			//IL_0bc2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bc7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bcf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bda: Expected O, but got Unknown
			//IL_0bdb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be6: Expected O, but got Unknown
			//IL_0bec: Expected O, but got Unknown
			//IL_0be7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bee: Expected O, but got Unknown
			//IL_0c1f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c24: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c2c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c37: Expected O, but got Unknown
			//IL_0c38: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c43: Expected O, but got Unknown
			//IL_0c49: Expected O, but got Unknown
			//IL_0c44: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c4b: Expected O, but got Unknown
			//IL_0c7c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c81: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c89: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c94: Expected O, but got Unknown
			//IL_0c95: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ca0: Expected O, but got Unknown
			//IL_0ca6: Expected O, but got Unknown
			//IL_0ca1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ca8: Expected O, but got Unknown
			//IL_0cd9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cde: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ce6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cf1: Expected O, but got Unknown
			//IL_0cf2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cfd: Expected O, but got Unknown
			//IL_0d03: Expected O, but got Unknown
			//IL_0cfe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d05: Expected O, but got Unknown
			//IL_0d36: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d3b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d43: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d4e: Expected O, but got Unknown
			//IL_0d4f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d5a: Expected O, but got Unknown
			//IL_0d60: Expected O, but got Unknown
			//IL_0d5b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d62: Expected O, but got Unknown
			//IL_0d93: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d98: Unknown result type (might be due to invalid IL or missing references)
			//IL_0da0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dab: Expected O, but got Unknown
			//IL_0dac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0db7: Expected O, but got Unknown
			//IL_0dbd: Expected O, but got Unknown
			//IL_0db8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dbf: Expected O, but got Unknown
			//IL_0df0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0df5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dfd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e08: Expected O, but got Unknown
			//IL_0e09: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e14: Expected O, but got Unknown
			//IL_0e1a: Expected O, but got Unknown
			//IL_0e15: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e1c: Expected O, but got Unknown
			//IL_0e4d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e52: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e5a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e65: Expected O, but got Unknown
			//IL_0e66: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e71: Expected O, but got Unknown
			//IL_0e77: Expected O, but got Unknown
			//IL_0e72: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e79: Expected O, but got Unknown
			//IL_0eaa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eaf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eb7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ec2: Expected O, but got Unknown
			//IL_0ec3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ece: Expected O, but got Unknown
			//IL_0ed4: Expected O, but got Unknown
			//IL_0ecf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ed6: Expected O, but got Unknown
			//IL_0f07: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f0c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f14: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f1f: Expected O, but got Unknown
			//IL_0f20: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f2b: Expected O, but got Unknown
			//IL_0f31: Expected O, but got Unknown
			//IL_0f2c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f33: Expected O, but got Unknown
			//IL_0f64: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f69: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f71: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f7c: Expected O, but got Unknown
			//IL_0f7d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f88: Expected O, but got Unknown
			//IL_0f8e: Expected O, but got Unknown
			//IL_0f89: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f90: Expected O, but got Unknown
			//IL_0fc1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fc6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fd9: Expected O, but got Unknown
			//IL_0fda: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fe5: Expected O, but got Unknown
			//IL_0feb: Expected O, but got Unknown
			//IL_0fe6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fed: Expected O, but got Unknown
			//IL_101e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1023: Unknown result type (might be due to invalid IL or missing references)
			//IL_102b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1036: Expected O, but got Unknown
			//IL_1037: Unknown result type (might be due to invalid IL or missing references)
			//IL_1042: Expected O, but got Unknown
			//IL_1048: Expected O, but got Unknown
			//IL_1043: Unknown result type (might be due to invalid IL or missing references)
			//IL_104a: Expected O, but got Unknown
			//IL_107b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1080: Unknown result type (might be due to invalid IL or missing references)
			//IL_1088: Unknown result type (might be due to invalid IL or missing references)
			//IL_1093: Expected O, but got Unknown
			//IL_1094: Unknown result type (might be due to invalid IL or missing references)
			//IL_109f: Expected O, but got Unknown
			//IL_10a5: Expected O, but got Unknown
			//IL_10a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_10a7: Expected O, but got Unknown
			//IL_10d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_10dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_10e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_10f0: Expected O, but got Unknown
			//IL_10f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_10fc: Expected O, but got Unknown
			//IL_1102: Expected O, but got Unknown
			//IL_10fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_1104: Expected O, but got Unknown
			//IL_1131: Unknown result type (might be due to invalid IL or missing references)
			//IL_1136: Unknown result type (might be due to invalid IL or missing references)
			//IL_1143: Expected O, but got Unknown
			//IL_113e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1145: Expected O, but got Unknown
			e0 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Random Explosion Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj = e0;
			FloatSliderOptions val = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val).Min = 0f;
			((BaseRangeOptions<float>)val).Max = 10f;
			FloatSliderConfigItem val2 = new FloatSliderConfigItem(obj, val);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val2);
			e1 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Outside Enemy Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj2 = e1;
			FloatSliderOptions val3 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val3).Min = 0f;
			((BaseRangeOptions<float>)val3).Max = 10f;
			FloatSliderConfigItem val4 = new FloatSliderConfigItem(obj2, val3);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val4);
			e2 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Trap Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj3 = e2;
			FloatSliderOptions val5 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val5).Min = 0f;
			((BaseRangeOptions<float>)val5).Max = 10f;
			FloatSliderConfigItem val6 = new FloatSliderConfigItem(obj3, val5);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val6);
			e3 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Turret Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj4 = e3;
			FloatSliderOptions val7 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val7).Min = 0f;
			((BaseRangeOptions<float>)val7).Max = 10f;
			FloatSliderConfigItem val8 = new FloatSliderConfigItem(obj4, val7);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val8);
			e4 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Mine Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj5 = e4;
			FloatSliderOptions val9 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val9).Min = 0f;
			((BaseRangeOptions<float>)val9).Max = 10f;
			FloatSliderConfigItem val10 = new FloatSliderConfigItem(obj5, val9);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val10);
			e5 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Inside Enemy Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj6 = e5;
			FloatSliderOptions val11 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val11).Min = 0f;
			((BaseRangeOptions<float>)val11).Max = 10f;
			FloatSliderConfigItem val12 = new FloatSliderConfigItem(obj6, val11);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val12);
			e6 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Hive Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj7 = e6;
			FloatSliderOptions val13 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val13).Min = 0f;
			((BaseRangeOptions<float>)val13).Max = 10f;
			FloatSliderConfigItem val14 = new FloatSliderConfigItem(obj7, val13);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val14);
			e7 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Random Prop Outside Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj8 = e7;
			FloatSliderOptions val15 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val15).Min = 0f;
			((BaseRangeOptions<float>)val15).Max = 10f;
			FloatSliderConfigItem val16 = new FloatSliderConfigItem(obj8, val15);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val16);
			e8 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Random Prop Inside Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj9 = e8;
			FloatSliderOptions val17 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val17).Min = 0f;
			((BaseRangeOptions<float>)val17).Max = 10f;
			FloatSliderConfigItem val18 = new FloatSliderConfigItem(obj9, val17);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val18);
			e9 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Random Item Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj10 = e9;
			FloatSliderOptions val19 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val19).Min = 0f;
			((BaseRangeOptions<float>)val19).Max = 10f;
			FloatSliderConfigItem val20 = new FloatSliderConfigItem(obj10, val19);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val20);
			e10 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Teleport Player Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj11 = e10;
			FloatSliderOptions val21 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val21).Min = 0f;
			((BaseRangeOptions<float>)val21).Max = 10f;
			FloatSliderConfigItem val22 = new FloatSliderConfigItem(obj11, val21);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val22);
			e11 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Lightning Bolt Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj12 = e11;
			FloatSliderOptions val23 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val23).Min = 0f;
			((BaseRangeOptions<float>)val23).Max = 10f;
			FloatSliderConfigItem val24 = new FloatSliderConfigItem(obj12, val23);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val24);
			e12 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Drunk Effect Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj13 = e12;
			FloatSliderOptions val25 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val25).Min = 0f;
			((BaseRangeOptions<float>)val25).Max = 10f;
			FloatSliderConfigItem val26 = new FloatSliderConfigItem(obj13, val25);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val26);
			e13 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Factory Light Flickering Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj14 = e13;
			FloatSliderOptions val27 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val27).Min = 0f;
			((BaseRangeOptions<float>)val27).Max = 10f;
			FloatSliderConfigItem val28 = new FloatSliderConfigItem(obj14, val27);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val28);
			e14 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Time Jump Forward Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj15 = e14;
			FloatSliderOptions val29 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val29).Min = 0f;
			((BaseRangeOptions<float>)val29).Max = 10f;
			FloatSliderConfigItem val30 = new FloatSliderConfigItem(obj15, val29);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val30);
			e15 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Time Jump Backward Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj16 = e15;
			FloatSliderOptions val31 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val31).Min = 0f;
			((BaseRangeOptions<float>)val31).Max = 10f;
			FloatSliderConfigItem val32 = new FloatSliderConfigItem(obj16, val31);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val32);
			e16 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Quicksand Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj17 = e16;
			FloatSliderOptions val33 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val33).Min = 0f;
			((BaseRangeOptions<float>)val33).Max = 10f;
			FloatSliderConfigItem val34 = new FloatSliderConfigItem(obj17, val33);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val34);
			e17 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Play Splash/Metal Hit Sound Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj18 = e17;
			FloatSliderOptions val35 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val35).Min = 0f;
			((BaseRangeOptions<float>)val35).Max = 10f;
			FloatSliderConfigItem val36 = new FloatSliderConfigItem(obj18, val35);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val36);
			e18 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Play Random Ship Sound Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj19 = e18;
			FloatSliderOptions val37 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val37).Min = 0f;
			((BaseRangeOptions<float>)val37).Max = 10f;
			FloatSliderConfigItem val38 = new FloatSliderConfigItem(obj19, val37);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val38);
			e19 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Attacking Worm Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj20 = e19;
			FloatSliderOptions val39 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val39).Min = 0f;
			((BaseRangeOptions<float>)val39).Max = 10f;
			FloatSliderConfigItem val40 = new FloatSliderConfigItem(obj20, val39);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val40);
			e20 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Activated Ladder Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj21 = e20;
			FloatSliderOptions val41 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val41).Min = 0f;
			((BaseRangeOptions<float>)val41).Max = 10f;
			FloatSliderConfigItem val42 = new FloatSliderConfigItem(obj21, val41);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val42);
			e21 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Fart Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj22 = e21;
			FloatSliderOptions val43 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val43).Min = 0f;
			((BaseRangeOptions<float>)val43).Max = 10f;
			FloatSliderConfigItem val44 = new FloatSliderConfigItem(obj22, val43);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val44);
			e22 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Flashbang Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj23 = e22;
			FloatSliderOptions val45 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val45).Min = 0f;
			((BaseRangeOptions<float>)val45).Max = 10f;
			FloatSliderConfigItem val46 = new FloatSliderConfigItem(obj23, val45);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val46);
			e23 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Glitch UI Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj24 = e23;
			FloatSliderOptions val47 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val47).Min = 0f;
			((BaseRangeOptions<float>)val47).Max = 10f;
			FloatSliderConfigItem val48 = new FloatSliderConfigItem(obj24, val47);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val48);
			e24 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Shake Screen (Earthquake) Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj25 = e24;
			FloatSliderOptions val49 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val49).Min = 0f;
			((BaseRangeOptions<float>)val49).Max = 10f;
			FloatSliderConfigItem val50 = new FloatSliderConfigItem(obj25, val49);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val50);
			e25 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Radiation Warning Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj26 = e25;
			FloatSliderOptions val51 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val51).Min = 0f;
			((BaseRangeOptions<float>)val51).Max = 10f;
			FloatSliderConfigItem val52 = new FloatSliderConfigItem(obj26, val51);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val52);
			e26 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Glitchy Car Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj27 = e26;
			FloatSliderOptions val53 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val53).Min = 0f;
			((BaseRangeOptions<float>)val53).Max = 10f;
			FloatSliderConfigItem val54 = new FloatSliderConfigItem(obj27, val53);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val54);
			e27 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Radio Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj28 = e27;
			FloatSliderOptions val55 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val55).Min = 0f;
			((BaseRangeOptions<float>)val55).Max = 10f;
			FloatSliderConfigItem val56 = new FloatSliderConfigItem(obj28, val55);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val56);
			e28 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn GIANT Soccerball Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj29 = e28;
			FloatSliderOptions val57 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val57).Min = 0f;
			((BaseRangeOptions<float>)val57).Max = 10f;
			FloatSliderConfigItem val58 = new FloatSliderConfigItem(obj29, val57);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val58);
			e29 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Play Pong or DIE Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj30 = e29;
			FloatSliderOptions val59 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val59).Min = 0f;
			((BaseRangeOptions<float>)val59).Max = 10f;
			FloatSliderConfigItem val60 = new FloatSliderConfigItem(obj30, val59);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val60);
			e30 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Add Extra Event Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj31 = e30;
			FloatSliderOptions val61 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val61).Min = 0f;
			((BaseRangeOptions<float>)val61).Max = 10f;
			FloatSliderConfigItem val62 = new FloatSliderConfigItem(obj31, val61);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val62);
			e31 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Web on Map Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj32 = e31;
			FloatSliderOptions val63 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val63).Min = 0f;
			((BaseRangeOptions<float>)val63).Max = 10f;
			FloatSliderConfigItem val64 = new FloatSliderConfigItem(obj32, val63);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val64);
			e32 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Burp Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj33 = e32;
			FloatSliderOptions val65 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val65).Min = 0f;
			((BaseRangeOptions<float>)val65).Max = 10f;
			FloatSliderConfigItem val66 = new FloatSliderConfigItem(obj33, val65);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val66);
			e33 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Mini Man (squish) Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj34 = e33;
			FloatSliderOptions val67 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val67).Min = 0f;
			((BaseRangeOptions<float>)val67).Max = 10f;
			FloatSliderConfigItem val68 = new FloatSliderConfigItem(obj34, val67);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val68);
			e34 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Among Us Jumpscare Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj35 = e34;
			FloatSliderOptions val69 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val69).Min = 0f;
			((BaseRangeOptions<float>)val69).Max = 10f;
			FloatSliderConfigItem val70 = new FloatSliderConfigItem(obj35, val69);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val70);
			e35 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Among Us Jumpscare Chance Multiplier", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj36 = e35;
			FloatSliderOptions val71 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val71).Min = 0f;
			((BaseRangeOptions<float>)val71).Max = 10f;
			FloatSliderConfigItem val72 = new FloatSliderConfigItem(obj36, val71);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val72);
			e36 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn obunga", 1f, "Multiplier for this specific event to occur (and link to a moon) in game.");
			ConfigEntry<float> obj37 = e36;
			FloatSliderOptions val73 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val73).Min = 0f;
			((BaseRangeOptions<float>)val73).Max = 10f;
			FloatSliderConfigItem val74 = new FloatSliderConfigItem(obj37, val73);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val74);
			e37 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Meteor Shower", 1f, "Multiplier for this specific event to occur (and link to a moon) in game (this can only occur one time per day).");
			ConfigEntry<float> obj38 = e37;
			FloatSliderOptions val75 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val75).Min = 0f;
			((BaseRangeOptions<float>)val75).Max = 10f;
			FloatSliderConfigItem val76 = new FloatSliderConfigItem(obj38, val75);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val76);
			e38 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Free Money (10% of bank + 5)", 1f, "Multiplier for this specific event to occur (and link to a moon) in game");
			ConfigEntry<float> obj39 = e38;
			FloatSliderOptions val77 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val77).Min = 0f;
			((BaseRangeOptions<float>)val77).Max = 10f;
			FloatSliderConfigItem val78 = new FloatSliderConfigItem(obj39, val77);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val78);
			e39 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Picklefy Nearby Textures", 1f, "Multiplier for this specific event to occur (and link to a moon) in game");
			ConfigEntry<float> obj40 = e39;
			FloatSliderOptions val79 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val79).Min = 0f;
			((BaseRangeOptions<float>)val79).Max = 10f;
			FloatSliderConfigItem val80 = new FloatSliderConfigItem(obj40, val79);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val80);
			e40 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Become Caseoh for some time (become big and slow down)", 1f, "Multiplier for this specific event to occur (and link to a moon) in game");
			ConfigEntry<float> obj41 = e40;
			FloatSliderOptions val81 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val81).Min = 0f;
			((BaseRangeOptions<float>)val81).Max = 10f;
			FloatSliderConfigItem val82 = new FloatSliderConfigItem(obj41, val81);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val82);
			e41 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Random sampled sound from ALL Mods and Vanilla", 1f, "Multiplier for this specific event to occur (and link to a moon) in game");
			ConfigEntry<float> obj42 = e41;
			FloatSliderOptions val83 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val83).Min = 0f;
			((BaseRangeOptions<float>)val83).Max = 10f;
			FloatSliderConfigItem val84 = new FloatSliderConfigItem(obj42, val83);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val84);
			e42 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Missile Silo", 1f, "Multiplier for this specific event to occur (and link to a moon) in game");
			ConfigEntry<float> obj43 = e42;
			FloatSliderOptions val85 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val85).Min = 0f;
			((BaseRangeOptions<float>)val85).Max = 10f;
			FloatSliderConfigItem val86 = new FloatSliderConfigItem(obj43, val85);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val86);
			e43 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Player enters vacuum effect.", 1f, "Multiplier for this specific event to occur (and link to a moon) in game");
			ConfigEntry<float> obj44 = e43;
			FloatSliderOptions val87 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val87).Min = 0f;
			((BaseRangeOptions<float>)val87).Max = 10f;
			FloatSliderConfigItem val88 = new FloatSliderConfigItem(obj44, val87);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val88);
			e44 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Random weather toggle (flood, fog, thunder, rain, eclipse, etc.)", 1f, "Multiplier for this specific event to occur (and link to a moon) in game");
			ConfigEntry<float> obj45 = e44;
			FloatSliderOptions val89 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val89).Min = 0f;
			((BaseRangeOptions<float>)val89).Max = 10f;
			FloatSliderConfigItem val90 = new FloatSliderConfigItem(obj45, val89);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val90);
			e45 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Ship and Player STRETCHING", 1f, "Multiplier for this specific event to occur (and link to a moon) in game");
			ConfigEntry<float> obj46 = e45;
			FloatSliderOptions val91 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val91).Min = 0f;
			((BaseRangeOptions<float>)val91).Max = 10f;
			FloatSliderConfigItem val92 = new FloatSliderConfigItem(obj46, val91);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val92);
			e46 = ((BaseUnityPlugin)this).Config.Bind<float>("Event Frequencies", "Spawn Spore Lizard Fog", 1f, "Multiplier for this specific event to occur (and link to a moon) in game");
			ConfigEntry<float> obj47 = e46;
			FloatSliderOptions val93 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val93).Min = 0f;
			((BaseRangeOptions<float>)val93).Max = 10f;
			FloatSliderConfigItem val94 = new FloatSliderConfigItem(obj47, val93);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val94);
			clevelandBrown = ((BaseUnityPlugin)this).Config.Bind<bool>("Cleveland Brown", "What does this setting do?", false, "My name is cleveland brown, and I am proud to meet. Right back at my hometown. With my new family.");
			BoolCheckBoxConfigItem val95 = new BoolCheckBoxConfigItem(clevelandBrown, new BoolCheckBoxOptions
			{
				RequiresRestart = false
			});
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val95);
		}

		public void bindVars()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_009c: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_00f0: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Expected O, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Expected O, but got Unknown
			//IL_01ea: Expected O, but got Unknown
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Expected O, but got Unknown
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Expected O, but got Unknown
			//IL_021a: Expected O, but got Unknown
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Expected O, but got Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Expected O, but got Unknown
			//IL_024a: Expected O, but got Unknown
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Expected O, but got Unknown
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Expected O, but got Unknown
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Expected O, but got Unknown
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Expected O, but got Unknown
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Expected O, but got Unknown
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Expected O, but got Unknown
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Expected O, but got Unknown
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Expected O, but got Unknown
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Expected O, but got Unknown
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Expected O, but got Unknown
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Expected O, but got Unknown
			levelOfChaos = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Level of Chaos", 0.6f, "Increases total outcomes linked to actions. Exponential \n (You will need to generate a new seed for this to take effect)");
			randomOutcomeMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Outcome Predictability", 0.5f, "Overall increases the chance for individual outcomes to happen, making them predictable. Generally increases chaos. \n (You will need to generate a new seed for this to take effect)");
			levelOfChaosScaling = ((BaseUnityPlugin)this).Config.Bind<float>("Scaling", "Level of Chaos Scaling", 0f, "The amount of additional chaos added per day of progression (adds to Level of Chaos setting)");
			ConfigEntry<float> obj = levelOfChaosScaling;
			FloatSliderOptions val = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val).Min = -1f;
			((BaseRangeOptions<float>)val).Max = 5f;
			FloatSliderConfigItem val2 = new FloatSliderConfigItem(obj, val);
			outcomeMultScaling = ((BaseUnityPlugin)this).Config.Bind<float>("Scaling", "Outcome Predictability Scaling", 0f, "The amount of additional outcome multiplier chance added per day of progression (adds to Outcome Predictability setting)");
			ConfigEntry<float> obj2 = outcomeMultScaling;
			FloatSliderOptions val3 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val3).Min = -1f;
			((BaseRangeOptions<float>)val3).Max = 5f;
			FloatSliderConfigItem val4 = new FloatSliderConfigItem(obj2, val3);
			fogChance = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Random fog chance", 0.2f, "Chance for a moon to have a random colored fog applied to it. The fog is unlikely to be worse than the fog you get from weather. \n (You will need to generate a new seed for this to take effect)");
			maxMonsterCount = ((BaseUnityPlugin)this).Config.Bind<float>("Advanced", "Monster Spawn Cap", 20f, "Max amount of monsters this mod can spawn per moon (some monsters are weighted higher than 1).");
			maxObjectCount = ((BaseUnityPlugin)this).Config.Bind<float>("Advanced", "Object Spawn Cap", 80f, "Max amount of objects this mod can spawn per moon (some objects are weighted higher than 1).");
			allowPong = ((BaseUnityPlugin)this).Config.Bind<bool>("Other", "Pong Allowed", true, "If pong will show up as an event (client side).");
			object obj3 = <>c.<>9__84_0;
			if (obj3 == null)
			{
				GenericButtonHandler val5 = delegate
				{
					EntropyEngine.EventHookMultiplier = levelOfChaos.Value;
					EntropyEngine.EventChanceMultiplier = randomOutcomeMultiplier.Value;
					EntropyEngine.LaunchEngine();
				};
				<>c.<>9__84_0 = val5;
				obj3 = (object)val5;
			}
			LethalConfigManager.AddConfigItem((BaseConfigItem)new GenericButtonConfigItem("General", "Generate new outcome set", "Restarts the mod, generating a completely new set of actions/outcomes for each moon.", "Generate New Seed", (GenericButtonHandler)obj3));
			ConfigEntry<float> obj4 = fogChance;
			FloatSliderOptions val6 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val6).Min = 0f;
			((BaseRangeOptions<float>)val6).Max = 1f;
			FloatSliderConfigItem val7 = new FloatSliderConfigItem(obj4, val6);
			ConfigEntry<float> obj5 = levelOfChaos;
			FloatSliderOptions val8 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val8).Min = 0f;
			((BaseRangeOptions<float>)val8).Max = 5f;
			FloatSliderConfigItem val9 = new FloatSliderConfigItem(obj5, val8);
			ConfigEntry<float> obj6 = randomOutcomeMultiplier;
			FloatSliderOptions val10 = new FloatSliderOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val10).Min = 0.01f;
			((BaseRangeOptions<float>)val10).Max = 5f;
			FloatSliderConfigItem val11 = new FloatSliderConfigItem(obj6, val10);
			FloatInputFieldConfigItem val12 = new FloatInputFieldConfigItem(maxMonsterCount, new FloatInputFieldOptions
			{
				RequiresRestart = false
			});
			FloatInputFieldConfigItem val13 = new FloatInputFieldConfigItem(maxObjectCount, new FloatInputFieldOptions
			{
				RequiresRestart = false
			});
			BoolCheckBoxConfigItem val14 = new BoolCheckBoxConfigItem(allowPong, new BoolCheckBoxOptions
			{
				RequiresRestart = false
			});
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val9);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val11);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val2);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val4);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val7);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val12);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val13);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val14);
			object obj7 = <>c.<>9__84_1;
			if (obj7 == null)
			{
				hook_Awake val15 = delegate(orig_Awake orig, MenuManager self)
				{
					if (clevelandBrown.Value)
					{
						self.menuMusic = clevelandBrownMusic;
					}
				};
				<>c.<>9__84_1 = val15;
				obj7 = (object)val15;
			}
			MenuManager.Awake += (hook_Awake)obj7;
			object obj8 = <>c.<>9__84_2;
			if (obj8 == null)
			{
				hook_Awake val16 = delegate(orig_Awake orig, ShipTeleporter self)
				{
					if (clevelandBrown.Value)
					{
						self.buttonAudio.clip = clevelandTele;
					}
					orig.Invoke(self);
				};
				<>c.<>9__84_2 = val16;
				obj8 = (object)val16;
			}
			ShipTeleporter.Awake += (hook_Awake)obj8;
			object obj9 = <>c.<>9__84_3;
			if (obj9 == null)
			{
				hook_ReactToNoise val17 = delegate(orig_ReactToNoise orig, ForestGiantAI self, float distanceToNoise, Vector3 noisePosition)
				{
					//IL_0025: Unknown result type (might be due to invalid IL or missing references)
					if (clevelandBrown.Value)
					{
						self.giantBurningAudio.PlayOneShot(gangnamOP);
					}
					orig.Invoke(self, distanceToNoise, noisePosition);
				};
				<>c.<>9__84_3 = val17;
				obj9 = (object)val17;
			}
			ForestGiantAI.ReactToNoise += (hook_ReactToNoise)obj9;
			object obj10 = <>c.<>9__84_4;
			if (obj10 == null)
			{
				hook_ReachedNodeInSearch val18 = delegate(orig_ReachedNodeInSearch orig, ForestGiantAI self)
				{
					if (clevelandBrown.Value)
					{
						self.giantBurningAudio.PlayOneShot(gangnamOP);
					}
					orig.Invoke(self);
				};
				<>c.<>9__84_4 = val18;
				obj10 = (object)val18;
			}
			ForestGiantAI.ReachedNodeInSearch += (hook_ReachedNodeInSearch)obj10;
			object obj11 = <>c.<>9__84_5;
			if (obj11 == null)
			{
				hook_BeginEatPlayer val19 = delegate(orig_BeginEatPlayer orig, ForestGiantAI self, PlayerControllerB playerBeingEaten, Vector3 enemyPosition, int enemyYRot)
				{
					//IL_0025: Unknown result type (might be due to invalid IL or missing references)
					if (clevelandBrown.Value)
					{
						self.giantBurningAudio.PlayOneShot(gangnamStyle);
					}
					orig.Invoke(self, playerBeingEaten, enemyPosition, enemyYRot);
				};
				<>c.<>9__84_5 = val19;
				obj11 = (object)val19;
			}
			ForestGiantAI.BeginEatPlayer += (hook_BeginEatPlayer)obj11;
			bindEvents();
			MonsterSpawnerConfig.Init(((BaseUnityPlugin)this).Config);
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "LethalChaos";

		public const string PLUGIN_NAME = "LethalChaos";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace LethalChaos.EntropySystem.MonsterSpawner
{
	public static class MonsterSpawnerConfig
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static GenericButtonHandler <0>__OnSpawnClicked;

			public static GenericButtonHandler <1>__OnPrintCoordsClicked;
		}

		private static ConfigEntry<string> _monsterName;

		private static ConfigEntry<float> _spawnX;

		private static ConfigEntry<float> _spawnY;

		private static ConfigEntry<float> _spawnZ;

		private static ConfigEntry<bool> _randomCoords;

		public static void Init(ConfigFile config)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_0100: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_0130: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Expected O, but got Unknown
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			//IL_0160: Expected O, but got Unknown
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Expected O, but got Unknown
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Expected O, but got Unknown
			_monsterName = config.Bind<string>("Monster Spawner", "Monster Name", "Flowerman", "Exact or partial name of the enemy to spawn (case-insensitive).");
			_spawnX = config.Bind<float>("Monster Spawner", "Spawn X", 0f, "World X coordinate to spawn at (ignored when Random Coords is on).");
			_spawnY = config.Bind<float>("Monster Spawner", "Spawn Y", 0f, "World Y coordinate to spawn at (ignored when Random Coords is on).");
			_spawnZ = config.Bind<float>("Monster Spawner", "Spawn Z", 0f, "World Z coordinate to spawn at (ignored when Random Coords is on).");
			_randomCoords = config.Bind<bool>("Monster Spawner", "Random Coords", true, "Pick a random outside AI node position instead of using X/Y/Z.");
			TextInputFieldConfigItem val = new TextInputFieldConfigItem(_monsterName, new TextInputFieldOptions
			{
				RequiresRestart = false,
				CharacterLimit = 64
			});
			BoolCheckBoxConfigItem val2 = new BoolCheckBoxConfigItem(_randomCoords, new BoolCheckBoxOptions
			{
				RequiresRestart = false
			});
			ConfigEntry<float> spawnX = _spawnX;
			FloatInputFieldOptions val3 = new FloatInputFieldOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val3).Min = -10000f;
			((BaseRangeOptions<float>)val3).Max = 10000f;
			FloatInputFieldConfigItem val4 = new FloatInputFieldConfigItem(spawnX, val3);
			ConfigEntry<float> spawnY = _spawnY;
			FloatInputFieldOptions val5 = new FloatInputFieldOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val5).Min = -10000f;
			((BaseRangeOptions<float>)val5).Max = 10000f;
			FloatInputFieldConfigItem val6 = new FloatInputFieldConfigItem(spawnY, val5);
			ConfigEntry<float> spawnZ = _spawnZ;
			FloatInputFieldOptions val7 = new FloatInputFieldOptions
			{
				RequiresRestart = false
			};
			((BaseRangeOptions<float>)val7).Min = -10000f;
			((BaseRangeOptions<float>)val7).Max = 10000f;
			FloatInputFieldConfigItem val8 = new FloatInputFieldConfigItem(spawnZ, val7);
			object obj = <>O.<0>__OnSpawnClicked;
			if (obj == null)
			{
				GenericButtonHandler val9 = OnSpawnClicked;
				<>O.<0>__OnSpawnClicked = val9;
				obj = (object)val9;
			}
			GenericButtonConfigItem val10 = new GenericButtonConfigItem("Monster Spawner", "Spawn Monster", "Spawns the specified monster. Works from host or client. Enable 'Random Coords' to ignore X/Y/Z and use a random outside node.", "Spawn", (GenericButtonHandler)obj);
			object obj2 = <>O.<1>__OnPrintCoordsClicked;
			if (obj2 == null)
			{
				GenericButtonHandler val11 = OnPrintCoordsClicked;
				<>O.<1>__OnPrintCoordsClicked = val11;
				obj2 = (object)val11;
			}
			GenericButtonConfigItem val12 = new GenericButtonConfigItem("Monster Spawner", "My Coordinates", "Displays your current world position in the HUD. Useful for filling in the X/Y/Z fields above.", "Print Coords", (GenericButtonHandler)obj2);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val2);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val4);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val6);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val8);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val10);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val12);
		}

		private static void OnSpawnClicked()
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			string text = _monsterName.Value?.Trim();
			bool value = _randomCoords.Value;
			Vector3 position = default(Vector3);
			((Vector3)(ref position))..ctor(_spawnX.Value, _spawnY.Value, _spawnZ.Value);
			if (string.IsNullOrWhiteSpace(text))
			{
				HUDManager instance = HUDManager.Instance;
				if (instance != null)
				{
					instance.DisplayTip("Monster Spawner", "Enter a monster name first.", true, false, "LC_Tip1");
				}
			}
			else if ((Object)(object)Plugin.rpcCalls == (Object)null)
			{
				HUDManager instance2 = HUDManager.Instance;
				if (instance2 != null)
				{
					instance2.DisplayTip("Monster Spawner", "Not in a game yet.", true, false, "LC_Tip1");
				}
			}
			else
			{
				NetworkManager singleton = NetworkManager.Singleton;
				ulong senderClientId = ((singleton != null) ? singleton.LocalClientId : 0);
				Plugin.rpcCalls.spawnMonsterServerRpc(text, position, value, senderClientId);
			}
		}

		private static void OnPrintCoordsClicked()
		{
			//IL_0049: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = GameNetworkManager.Instance?.localPlayerController;
			if ((Object)(object)val == (Object)null)
			{
				HUDManager instance = HUDManager.Instance;
				if (instance != null)
				{
					instance.DisplayTip("Monster Spawner", "Not in a game.", true, false, "LC_Tip1");
				}
				return;
			}
			Vector3 position = ((Component)val).transform.position;
			HUDManager instance2 = HUDManager.Instance;
			if (instance2 != null)
			{
				instance2.DisplayTip("Your Coordinates", $"X: {position.x:F1}  Y: {position.y:F1}  Z: {position.z:F1}", false, false, "LC_Tip1");
			}
		}
	}
}
namespace LethalChaos.EntropySystem.PrefabScripts
{
	public class CompanyMissile : MonoBehaviour
	{
		protected float missileSpeed = 0.2f;

		private float currentMissileSpeed = 0.35f;

		private bool hitWall = true;

		private float despawnTimer;

		private Random missileFlyRandom;

		private float forwardDistance;

		private float lastRotationDistance;

		protected float missileWarbleLevel = 0.73f;

		private static int missilesFired;

		private void Start()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			missileFlyRandom = new Random((int)(((Component)this).transform.position.x + ((Component)this).transform.position.y) + missilesFired);
			hitWall = false;
			missilesFired++;
		}

		public void setMissileWarble(float val)
		{
			missileWarbleLevel = val;
		}

		public void setMissileSpeed(float val)
		{
			missileSpeed = val;
		}

		private void FixedUpdate()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			if (hitWall)
			{
				return;
			}
			if (despawnTimer < 5f)
			{
				despawnTimer += Time.deltaTime;
				CheckCollision();
				Transform transform = ((Component)this).transform;
				transform.position += ((Component)this).transform.forward * missileSpeed * currentMissileSpeed;
				forwardDistance += missileSpeed * currentMissileSpeed;
				if (forwardDistance - lastRotationDistance > 2f)
				{
					lastRotationDistance = forwardDistance;
					Transform transform2 = ((Component)this).transform;
					transform2.rotation *= Quaternion.Euler(new Vector3(15f * missileWarbleLevel * (float)(missileFlyRandom.NextDouble() * 2.0 - 1.0), 7f * missileWarbleLevel * (float)(missileFlyRandom.NextDouble() * 2.0 - 1.0), 15f * missileWarbleLevel * (float)(missileFlyRandom.NextDouble() * 2.0 - 1.0)));
				}
				currentMissileSpeed += 0.05f;
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void CheckCollision()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(((Component)this).transform.position, ((Component)this).transform.forward, ref val, 0.6f * currentMissileSpeed, 526592, (QueryTriggerInteraction)1) || Physics.Raycast(((Component)this).transform.position, ((Component)this).transform.forward, ref val, 0.6f * currentMissileSpeed, 8, (QueryTriggerInteraction)2))
			{
				hitWall = true;
				Landmine.SpawnExplosion(((Component)this).transform.position - ((Component)this).transform.forward * 0.5f, true, 4f, 7f, 15, 30f, (GameObject)null, true);
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}
}
namespace LethalChaos.EntropySystem.Networking
{
	public class LethalNet : NetworkBehaviour
	{
		public static Dictionary<string, Color> albedoMap = new Dictionary<string, Color>();

		public static Dictionary<string, float> meanMap = new Dictionary<string, float>();

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			Debug.Log((object)("[LethalNet] LethalNet has spawned on the network. IsHost=" + ((NetworkBehaviour)this).IsHost + " IsServer=" + ((NetworkBehaviour)this).IsServer));
		}

		public PlayerControllerB getPlayer(ulong playerId)
		{
			PlayerControllerB[] allPlayerScripts = RoundManager.Instance.playersManager.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (((NetworkBehaviour)val).NetworkObjectId == playerId)
				{
					return val;
				}
			}
			return null;
		}

		[ClientRpc]
		public void lightFlickerClientRpc()
		{
			//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)
			//IL_00c1: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3666616739u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3666616739u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					RoundManager instance = RoundManager.Instance;
					instance.FlickerLights(false, false);
				}
			}
		}

		[ClientRpc]
		public void makePlayerDrunkClientRpc(ulong 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)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1533410096u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerid);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1533410096u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB player = getPlayer(playerid);
				if (Object.op_Implicit((Object)(object)player))
				{
					player.drunkness = 1f;
					player.drunknessSpeed = 0.4f;
				}
			}
		}

		[ClientRpc]
		public void timeJumpForwardClientRpc()
		{
			//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)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2992081406u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2992081406u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				GameObject val3 = GameObject.Find("TimeAndWeather");
				TimeOfDay component = val3.GetComponent<TimeOfDay>();
				if (component.globalTime + 10f < component.globalTimeAtEndOfDay)
				{
					component.globalTime += 10f;
					HUDManager.Instance.DisplayTip("WARNING", "Jumped time forward by 10 minutes", false, false, "LC_Tip1");
				}
			}
		}

		[ClientRpc]
		public void notifyObungaClientRpc()
		{
			//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)
			//IL_00c1: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3292847749u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3292847749u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					GameObject val3 = GameObject.Find("TimeAndWeather");
					TimeOfDay component = val3.GetComponent<TimeOfDay>();
					HUDManager.Instance.DisplayTip("LOOK OUT!", "Obunga Has Arrived", true, false, "LC_Tip1");
				}
			}
		}

		[ClientRpc]
		public void notifyObungaLeftClientRpc()
		{
			//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)
			//IL_00c1: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(529829256u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 529829256u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					GameObject val3 = GameObject.Find("TimeAndWeather");
					TimeOfDay component = val3.GetComponent<TimeOfDay>();
					HUDManager.Instance.DisplayTip("Thank God.", "Obunga left this plane of existence", true, false, "LC_Tip1");
				}
			}
		}

		[ClientRpc]
		public void newRandomEventWarningClientRpc(int outcomeCount)
		{
			//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)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2694128158u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, outcomeCount);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2694128158u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (outcomeCount == 1)
				{
					HUDManager.Instance.DisplayTip("DANGER", "New random outcome added to planet", true, false, "LC_Tip1");
				}
				else
				{
					HUDManager.Instance.DisplayTip("DANGER", outcomeCount + " random outcomes added to planet", true, false, "LC_Tip1");
				}
			}
		}

		[ClientRpc]
		public void timeJumpBackwardClientRpc()
		{
			//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)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1911799468u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1911799468u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				GameObject val3 = GameObject.Find("TimeAndWeather");
				TimeOfDay component = val3.GetComponent<TimeOfDay>();
				if (component.globalTime - 10f >= 100f)
				{
					component.globalTime -= 10f;
					HUDManager.Instance.DisplayTip("WARNING", "Jumped time backward by 10 minutes", false, false, "LC_Tip1");
				}
			}
		}

		[ClientRpc]
		public void teleportPlayerClientRpc(ulong playerid, Vector3 position)
		{
			//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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3590497892u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerid);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3590497892u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB player = getPlayer(playerid);
				PlayerControllerB component = ((Component)player).GetComponent<PlayerControllerB>();
				if (!(position == Vector3.zero))
				{
					component.playerRigidbody.position = position;
				}
			}
		}

		[ClientRpc]
		public void fardClientRpc(ulong 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)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3019070676u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerid);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3019070676u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB player = getPlayer(playerid);
				PlayerControllerB component = ((Component)player).GetComponent<PlayerControllerB>();
				switch (EntropyEngine.rnd.Next(0, 3))
				{
				case 0:
					AudioSource.PlayClipAtPoint(Plugin.fard1, ((Component)player).gameObject.transform.position, 1f);
					break;
				case 1:
					AudioSource.PlayClipAtPoint(Plugin.fard2, ((Component)player).gameObject.transform.position, 1f);
					break;
				case 2:
					AudioSource.PlayClipAtPoint(Plugin.fard3, ((Component)player).gameObject.transform.position, 1f);
					break;
				}
			}
		}

		[ClientRpc]
		public void burpClientRpc(ulong 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)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1800866797u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerid);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1800866797u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB player = getPlayer(playerid);
				PlayerControllerB component = ((Component)player).GetComponent<PlayerControllerB>();
				switch (EntropyEngine.rnd.Next(0, 3))
				{
				case 0:
					AudioSource.PlayClipAtPoint(Plugin.burp1, ((Component)player).gameObject.transform.position, 1f);
					break;
				case 1:
					AudioSource.PlayClipAtPoint(Plugin.burp2, ((Component)player).gameObject.transform.position, 1f);
					break;
				case 2:
					AudioSource.PlayClipAtPoint(Plugin.burp3, ((Component)player).gameObject.transform.position, 1f);
					break;
				}
			}
		}

		[ClientRpc]
		public void squishClientRpc(ulong 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)
			//IL_00ce: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3585418606u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerid);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3585418606u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					PlayerControllerB player = getPlayer(playerid);
					squishEffect(player);
				}
			}
		}

		[ClientRpc]
		public void expandClientRpc(ulong 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)
			//IL_00ce: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2540607385u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerid);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2540607385u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					PlayerControllerB player = getPlayer(playerid);
					expandEffect(player);
				}
			}
		}

		[ClientRpc]
		public void medsClientRpc(ulong 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)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(857728355u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerid);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 857728355u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB player = getPlayer(playerid);
				if (player.health + 30 >= 100)
				{
					player.DamagePlayer((100 - player.health) * -1, true, true, (CauseOfDeath)0, 0, false, default(Vector3));
				}
				else
				{
					player.DamagePlayer(-30, true, true, (CauseOfDeath)0, 0, false, default(Vector3));
				}
				AudioSource.PlayClipAtPoint(Plugin.medkit, ((Component)player).gameObject.transform.position, 1f);
			}
		}

		public async void squishEffect(PlayerControllerB player)
		{
			AudioSource.PlayClipAtPoint(Plugin.squish, ((Component)player).gameObject.transform.position, 1f);
			Transform transform = ((Component)player).transform;
			transform.localScale *= 0.4f;
			player.movementSpeed *= 2f;
			await Task.Delay(EntropyEngine.rnd.Next(100, 25000));
			player.movementSpeed = 4.6f;
			((Component)player).transform.localScale = new Vector3(1f, 1f, 1f);
		}

		public async void expandEffect(PlayerControllerB player)
		{
			AudioSource.PlayClipAtPoint(Plugin.expandSound, ((Component)player).gameObject.transform.position, 1f);
			Transform transform = ((Component)player).transform;
			transform.localScale *= 1.6f;
			player.movementSpeed /= 1.4f;
			await Task.Delay(EntropyEngine.rnd.Next(100, 50000));
			player.movementSpeed = 4.6f;
			((Component)player).transform.localScale = new Vector3(1f, 1f, 1f);
		}

		[ClientRpc]
		public void stunClientRpc(ulong 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)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2392522162u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerid);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2392522162u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					PlayerControllerB player = getPlayer(playerid);
					PlayerControllerB component = ((Component)player).GetComponent<PlayerControllerB>();
					StunGrenadeItem.StunExplosion(((Component)player).transform.position, true, 1f, 1f, 1f, false, (PlayerControllerB)null, (PlayerControllerB)null, 0f);
				}
			}
		}

		[ClientRpc]
		public void randomSuitChangeClientRpc(ulong 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)
			//IL_00ce: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1920748102u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerid);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1920748102u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}
		}

		[ClientRpc]
		public void spawnEggExplosionClientRpc(Vector3 position)
		{
			//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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2285070379u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2285070379u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}
		}

		[ClientRpc]
		public void applyModifiersClientRpc(float jumpForce, float movementSpeed, float playerReach, bool fogEnabled, float meanFreePath, Color fogColor)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Invalid comparison between Unknown and I4
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3729177168u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref jumpForce, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref movementSpeed, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref playerReach, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref fogEnabled, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref meanFreePath, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref fogColor);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3729177168u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			try
			{
				float num = jumpForce;
				float num2 = movementSpeed;
				float num3 = playerReach;
				Debug.Log((object)("jf = " + num));
				Debug.Log((object)("ms = " + num2));
				Debug.Log((object)("pr = " + num3));
				GameObject[] players = entropyBlaster.getPlayers();
				float num4 = float.PositiveInfinity;
				GameObject[] array = players;
				foreach (GameObject val3 in array)
				{
					PlayerControllerB component = val3.GetComponent<PlayerControllerB>();
					component.jumpForce = jumpForce;
					component.movementSpeed = movementSpeed;
					component.grabDistance = playerReach;
				}
				GameObject val4 = GameObject.Find("TimeAndWeather");
				GameObject gameObject = ((Component)val4.transform.Find("Foggy")).gameObject;
				Debug.Log((object)("fog GO: " + ((Object)gameObject).name + " - " + ((object)gameObject).GetType()?.ToString() + " - " + ((object)gameObject).ToString()));
				GameObject val5 = gameObject;
				LocalVolumetricFog component2 = val5.GetComponent<LocalVolumetricFog>();
				if (fogEnabled)
				{
					Debug.Log((object)"FogEnabled");
					val5.SetActive(true);
					string planet = EntropyEngine.getMoonHost().planet;
					if (!albedoMap.ContainsKey(planet))
					{
						albedoMap.Add(planet, component2.parameters.albedo);
					}
					if (!meanMap.ContainsKey(planet))
					{
						meanMap.Add(planet, component2.parameters.meanFreePath);
					}
					component2.parameters.albedo = fogColor;
					component2.parameters.meanFreePath = meanFreePath;
					return;
				}
				Debug.Log((object)"FogDisabled");
				RoundManager instance = RoundManager.Instance;
				if ((int)instance.currentLevel.currentWeather != 3)
				{
					val5.SetActive(false);
				}
				string planet2 = EntropyEngine.getMoonHost().planet;
				if (albedoMap.ContainsKey(planet2))
				{
					component2.parameters.albedo = albedoMap[planet2];
				}
				else if (albedoMap.Keys.Count > 0)
				{
					component2.parameters.albedo = albedoMap.First().Value;
				}
				if (meanMap.ContainsKey(planet2))
				{
					component2.parameters.meanFreePath = meanMap[planet2];
				}
				else if (meanMap.Keys.Count > 0)
				{
					component2.parameters.meanFreePath = meanMap.First().Value;
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Lethal Chaos: applyModifiers method failure -> " + ex.ToString()));
			}
		}

		[ClientRpc]
		public void glitchHudClientRpc()
		{
			//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)
			//IL_00c1: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2351394233u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2351394233u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					glitch();
				}
			}
		}

		public async void glitch()
		{
			try
			{
				GameObject UI = GameObject.Find("HudBaseRotation");
				UI.transform.rotation = new Quaternion((float)EntropyEngine.rnd.Next(0, 90), (float)EntropyEngine.rnd.Next(0, 90), (float)EntropyEngine.rnd.Next(0, 90), UI.transform.rotation.w);
				await Task.Delay(EntropyEngine.rnd.Next(50, 10000));
				UI.transform.rotation = new Quaternion(0f, 0f, 0f, UI.transform.rotation.w);
			}
			catch (Exception ex)
			{
				Exception e = ex;
				Debug.LogError((object)e);
			}
		}

		[ClientRpc]
		public void radiationWarningHudClientRpc()
		{
			//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)
			//IL_00c1: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2093172058u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2093172058u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					HUDManager.Instance.RadiationWarningHUD();
				}
			}
		}

		[ClientRpc]
		public void shakeScreenClientRpc()
		{
			//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)
			//IL_00c1: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2020295525u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2020295525u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					HUDManager.Instance.ShakeCamera((ScreenShakeType)3);
				}
			}
		}

		[ClientRpc]
		public void spawnExplosionClientRpc(Vector3 position)
		{
			//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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1634251385u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1634251385u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Landmine.SpawnExplosion(position + Vector3.up, true, 5.7f, 6.4f, 50, 0f, (GameObject)null, false);
				}
			}
		}

		[ClientRpc]
		public void lightningStrikeClientRpc(Vector3 position)
		{
			//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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3426369828u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3426369828u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			RoundManager instance = RoundManager.Instance;
			GameObject val3 = GameObject.Find("TimeAndWeather");
			GameObject val4 = null;
			for (int i = 0; i < val3.transform.GetChildCount(); i++)
			{
				GameObject gameObject = ((Component)val3.transform.GetChild(i)).gameObject;
				if (((Object)gameObject).name.Equals("Stormy"))
				{
					Debug.Log((object)"Lethal Chaos: Found Stormy!");
					val4 = gameObject;
				}
			}
			if ((Object)(object)val4 != (Object)null)
			{
				val4.SetActive(true);
			}
			else
			{
				Debug.LogError((object)"Lethal Chaos: Failed to find Stormy Weather container (LBolt)!");
			}
			if (((NetworkBehaviour)instance).IsHost)
			{
				instance.LightningStrikeClientRpc(position);
			}
		}

		[ClientRpc]
		public void bigBallsClientRpc(ulong netid)
		{
			//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)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(588868959u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, netid);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 588868959u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			SoccerBallProp[] array = Object.FindObjectsOfType<SoccerBallProp>();
			SoccerBallProp[] array2 = array;
			foreach (SoccerBallProp val3 in array2)
			{
				if (((NetworkBehaviour)val3).NetworkObjectId == netid)
				{
					((Component)val3).gameObject.transform.localScale = new Vector3(2f, 2f, 2f);
				}
			}
		}

		[ClientRpc]
		public void startPongGameClientRpc(ulong netid)
		{
			//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)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3732802136u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, netid);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3732802136u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			if (!entropyBlaster.playingPong && Plugin.allowPong.Value)
			{
				if (((NetworkBehaviour)localPlayerController).NetworkObjectId == netid)
				{
					Debug.Log((object)("Lethal Chaos: Client RPC Pong trigger on " + netid));
					GameObject pong = Plugin.Pong;
					Debug.Log((object)pong);
					GameObject val3 = Object.Instantiate<GameObject>(pong, new Vector3(0f, 0f, 0f), Quaternion.identity);
					val3.GetComponent<CanvasScaler>().scaleFactor = 20f;
					val3.GetComponent<Canvas>().renderMode = (RenderMode)0;
					((Component)val3.transform.Find("Ball")).GetComponent<Ball>().game = val3;
					((Component)val3.transform.Find("Ball")).GetComponent<Ball>().playerTarget = ((Component)localPlayerController).GetComponent<PlayerControllerB>();
					entropyBlaster.playingPong = true;
				}
				else
				{
					Debug.Log((object)("Lethal Chaos: Client RPC Pong BLOCK trigger on " + netid));
				}
			}
		}

		[ClientRpc]
		public void startAmogusClientRpc(ulong netid)
		{
			//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)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2841350069u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, netid);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2841350069u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
				if (!entropyBlaster.playingPong)
				{
					mogus(localPlayerController, netid);
				}
			}
		}

		[ClientRpc]
		public void activateLadderClientRpc(ulong netid)
		{
			//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)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(874795037u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, netid);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 874795037u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			ExtensionLadderItem[] array = Resources.FindObjectsOfTypeAll<ExtensionLadderItem>();
			ExtensionLadderItem[] array2 = array;
			foreach (ExtensionLadderItem val3 in array2)
			{
				if (((NetworkBehaviour)val3).NetworkObjectId == netid)
				{
					((GrabbableObject)val3).ItemActivate(true, true);
					((GrabbableObject)val3).UseItemOnClient(true);
				}
			}
		}

		[ClientRpc]
		public void picklefyClientRpc(Vector3 position)
		{
			//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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2882102479u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2882102479u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			Collider[] array = Physics.OverlapSphere(position, 10f);
			Collider[] array2 = array;
			foreach (Collider val3 in array2)
			{
				GameObject gameObject = ((Component)val3).gameObject;
				Renderer component = gameObject.GetComponent<Renderer>();
				if ((Object)(object)component != (Object)null)
				{
					int num = component.materials.Length;
					Material[] array3 = (Material[])(object)new Material[num];
					for (int j = 0; j < num; j++)
					{
						array3[j] = Plugin.pickleMaterial;
					}
					component.materials = array3;
				}
			}
		}

		[ClientRpc]
		public void setCreditsClientRpc(int newGroupCreditsAmount)
		{
			//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)
			//IL_00ce: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3042755761u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, newGroupCreditsAmount);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3042755761u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					HUDManager.Instance.ShakeCamera((ScreenShakeType)0);
					int num = newGroupCreditsAmount - Object.FindObjectOfType<Terminal>().groupCredits;
					HUDManager.Instance.DisplayTip("Yipee!", "Added " + num + " credits to your bank account", false, false, "LC_Tip1");
					Object.FindObjectOfType<Terminal>().groupCredits = newGroupCreditsAmount;
				}
			}
		}

		public async void mogus(PlayerControllerB player, ulong netid)
		{
			if (((NetworkBehaviour)player).NetworkObjectId == netid)
			{
				Debug.Log((object)("Lethal Chaos: Client RPC AMOGUS trigger on " + netid));
				AudioSource.PlayClipAtPoint(Plugin.mogusSound, ((Component)player).gameObject.transform.position, 1f);
				GameObject go = Plugin.Amogus;
				Debug.Log((object)go);
				GameObject _game = Object.Instantiate<GameObject>(go, new Vector3(0f, 0f, 0f), Quaternion.identity);
				_game.GetComponent<CanvasScaler>().scaleFactor = 30f;
				_game.GetComponent<Canvas>().renderMode = (RenderMode)0;
				await Task.Delay(1500);
				Object.Destroy((Object)(object)_game);
			}
			else
			{
				Debug.Log((object)("Lethal Chaos: Client RPC amogus BLOCK trigger on " + netid));
			}
		}

		[ClientRpc]
		public void qsandClientRpc(Vector3 position)
		{
			//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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3232205781u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3232205781u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					RoundManager instance = RoundManager.Instance;
					GameObject item = Object.Instantiate<GameObject>(instance.quicksandPrefab, position, Quaternion.identity, new GameObject().transform);
					EntityDestructionManager.destroyOnFail.Add(item);
					EntityDestructionManager.destroyOnLeave.Add(item);
				}
			}
		}

		[ClientRpc]
		public void completelyRandomSoundClientRpc(string name, Vector3 position)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2338797674u, val, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(name, false);
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2338797674u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			AudioClip[] array = Resources.FindObjectsOfTypeAll<AudioClip>();
			AudioClip[] array2 = array;
			foreach (AudioClip val3 in array2)
			{
				if (((Object)val3).name.Equals(name))
				{
					AudioSource.PlayClipAtPoint(val3, position);
				}
			}
		}

		[ClientRpc]
		public void makeMissileClientRpc(Vector3 pos, Quaternion rotation)
		{
			//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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1053493706u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref pos);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref rotation);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1053493706u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					GameObject val3 = Object.Instantiate<GameObject>(Plugin.missilePrefab, pos, rotation);
					CompanyMissile component = val3.GetComponent<CompanyMissile>();
					component.setMissileSpeed(0.4f);
					component.setMissileWarble(1f);
					AudioSource.PlayClipAtPoint(Plugin.blastNoise, pos);
					HUDManager.Instance.ShakeCamera((ScreenShakeType)0);
				}
			}
		}

		[ClientRpc]
		public void startSuckClipClientRpc()
		{
			//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)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3169009484u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3169009484u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB[] allPlayerScripts = RoundManager.Instance.playersManager.allPlayerScripts;
			foreach (PlayerControllerB val3 in allPlayerScripts)
			{
				if (Object.op_Implicit((Object)(object)StartOfRound.Instance.airPressureSFX))
				{
					AudioSource.PlayClipAtPoint(StartOfRound.Instance.suckedIntoSpaceSFX, ((Component)val3).gameObject.transform.position);
				}
				if (Object.op_Implicit((Object)(object)StartOfRound.Instance.airPressureSFX))
				{
					AudioSource.PlayClipAtPoint(StartOfRound.Instance.airPressureSFX, ((Component)val3).gameObject.transform.position);
				}
				if (Object.op_Implicit((Object)(object)StartOfRound.Instance.shipDoorAudioSource.clip))
				{
					AudioSource.PlayClipAtPoint(StartOfRound.Instance.shipDoorAudioSource.clip, ((Component)val3).gameObject.transform.position);
				}
			}
			shipSuck();
		}

		[ClientRpc]
		public void toggleWeatherClientRpc(string name)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3204882390u, val, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(name, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3204882390u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			GameObject val3 = GameObject.Find("TimeAndWeather");
			TimeOfDay component = val3.GetComponent<TimeOfDay>();
			List<GameObject> list = new List<GameObject>();
			foreach (Transform item in val3.transform)
			{
				Transform val4 = item;
				GameObject gameObject = ((Component)val4).gameObject;
				Debug.Log((object)("ChildACT: " + ((Object)gameObject).name + " vs " + name));
				if (name.ToLower().Equals(((Object)gameObject).name.ToLower()))
				{
					Debug.Log((object)("TOGGLING: " + (object)gameObject));
					gameObject.SetActive(!gameObject.activeInHierarchy);
				}
			}
		}

		[ClientRpc]
		public void shipStretchClientRpc(int code, int time)
		{
			//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)
			//IL_00db: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(553391869u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, code);
					BytePacker.WriteValueBitPacked(val2, time);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 553391869u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					shipStretch(code, time);
				}
			}
		}

		public async void shipStretch(int code, int time)
		{
			Debug.Log((object)("Lethal Chaos: stretch rpc code = " + code + " time = " + time));
			GameObject GO = GameObject.Find("HangarShip");
			if (Object.op_Implicit((Object)(object)GO))
			{
				float x = GO.transform.localScale.x;
				float y = GO.transform.localScale.y;
				float z = GO.transform.localScale.z;
				switch (code)
				{
				case 0:
					MonoBehaviour.print((object)"GO SET 0");
					GO.transform.localScale = new Vector3(2f, y, z);
					break;
				case 1:
					MonoBehaviour.print((object)"GO SET 1");
					GO.transform.localScale = new Vector3(x, 2f, z);
					break;
				case 2:
					MonoBehaviour.print((object)"GO SET 2");
					GO.transform.localScale = new Vector3(x, y, 2f);
					break;
				}
				await Task.Delay(time);
				GO.transform.localScale = new Vector3(1f, 1f, 1f);
			}
			else
			{
				Debug.LogError((object)"Lethal Chaos: Can't find ship to stretch!");
			}
		}

		[ClientRpc]
		public void pufferClientRpc(Vector3 position)
		{
			//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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3075557142u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3075557142u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					GameObject val3 = Object.Instantiate<GameObject>(Plugin.pufferCloud, position, Quaternion.identity, new GameObject().transform);
					AudioSource.PlayClipAtPoint(Plugin.pufferSound, position, 1f);
				}
			}
		}

		public async void shipSuck()
		{
			try
			{
				StartOfRound.Instance.suckingPlayersOutOfShip = true;
				await Task.Delay(EntropyEngine.rnd.Next(50, 1000));
				StartOfRound.Instance.suckingPlayersOutOfShip = false;
			}
			catch (Exception)
			{
			}
		}

		[ClientRpc]
		public void queueRandomEnemyBoltClientRpc()
		{
			//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)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1159547838u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1159547838u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			EnemyAI[] array = Object.FindObjectsOfType<EnemyAI>();
			EnemyAI val3 = array[EntropyEngine.rnd.Next(0, array.Length)];
			Debug.Log((object)("enemy to convert: " + (object)val3));
			GrabbableObject bolt = getBolt();
			MeshFilter component = ((Component)bolt).GetComponent<MeshFilter>();
			Debug.Log((object)("bolt: " + (object)bolt));
			Debug.Log((object)("bolt filter: " + (object)component));
			Debug.Log((object)"Destroying Mesh Renderer and Filter...");
			Debug.Log((object)("object = " + (object)val3));
			Debug.Log((object)"Adding Filters");
			MeshFilter[] componentsInChildren = ((Component)val3).gameObject.GetComponentsInChildren<MeshFilter>();
			foreach (MeshFilter val4 in componentsInChildren)
			{
				Debug.Log((object)("object filter: " + (object)val4));
				if ((Object)(object)val4 != (Object)null)
				{
					val4.mesh = component.mesh;
				}
			}
			SkinnedMeshRenderer[] componentsInChildren2 = ((Component)val3).gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();
			foreach (SkinnedMeshRenderer val5 in componentsInChildren2)
			{
				Debug.Log((object)("object skin filter: " + (object)val5));
				if ((Object)(object)val5 != (Object)null)
				{
					val5.sharedMesh = component.mesh;
				}
			}
		}

		public GrabbableObject getBolt()
		{
			GrabbableObject[] array = Object.FindObjectsOfType<GrabbableObject>();
			GrabbableObject[] array2 = array;
			foreach (GrabbableObject val in array2)
			{
				string text = val.itemProperties.itemName.ToLower();
				if (text.Contains("bolt") && text.Contains("big"))
				{
					return val;
				}
			}
			return null;
		}

		[ServerRpc(RequireOwnership = false)]
		public void spawnMonsterServerRpc(string monsterName, Vector3 position, bool useRandom, ulong senderClientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2086484989u, val, (RpcDelivery)0);
				bool flag = monsterName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(monsterName, false);
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref useRandom, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val2, senderClientId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2086484989u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			Debug.Log((object)$"[LethalNet] spawnMonsterServerRpc received -- monster='{monsterName}' useRandom={useRandom} sender={senderClientId}");
			RoundManager instance = RoundManager.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.currentLevel == (Object)null)
			{
				Debug.LogWarning((object)"[LethalNet] Spawn blocked -- no moon loaded.");
				spawnFailClientRpc(senderClientId, "No moon loaded.");
				return;
			}
			Vector3 val3 = (useRandom ? GetRandomOutsideNode(instance) : position);
			if (val3 == Vector3.zero)
			{
				Debug.LogWarning((object)"[LethalNet] Spawn blocked -- no valid position.");
				spawnFailClientRpc(senderClientId, "Could not find a valid spawn position.");
				return;
			}
			GameObject val4 = FindEnemyPrefab(monsterName, instance);
			if ((Object)(object)val4 == (Object)null)
			{
				Debug.LogWarning((object)("[LethalNet] No enemy matching '" + monsterName + "'."));
				spawnFailClientRpc(senderClientId, "Enemy '" + monsterName + "' not found.");
				return;
			}
			try
			{
				GameObject val5 = Object.Instantiate<GameObject>(val4, val3, Quaternion.identity);
				NetworkObject componentInChildren = val5.GetComponentInChildren<NetworkObject>();
				if ((Object)(object)componentInChildren == (Object)null)
				{
					Debug.LogError((object)"[LethalNet] Enemy prefab has no NetworkObject!");
					Object.Destroy((Object)(object)val5);
					spawnFailClientRpc(senderClientId, "Prefab missing NetworkObject.");
					return;
				}
				componentInChildren.Spawn(true);
				EnemyAI component = val5.GetComponent<EnemyAI>();
				if ((Object)(object)component != (Object)null)
				{
					instance.SpawnedEnemies.Add(component);
					EnemyType enemyType = component.enemyType;
					enemyType.numberSpawned++;
				}
				EntityDestructionManager.destroyOnLeave.Add(val5);
				Debug.Log((object)$"[LethalNet] Spawned '{monsterName}' at {val3}.");
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[LethalNet] Spawn threw: {arg}");
				spawnFailClientRpc(senderClientId, "Exception during spawn -- check logs.");
			}
		}

		[ClientRpc]
		public void spawnFailClientRpc(ulong targetClientId, string reason)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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_0095: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(572993813u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, targetClientId);
				bool flag = reason != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(reason, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 572993813u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (NetworkManager.Singleton.LocalClientId == targetClientId)
			{
				HUDManager instance = HUDManager.Instance;
				if (instance != null)
				{
					instance.DisplayTip("Monster Spawner", "Spawn failed: " + reason, true, false, "LC_Tip1");
				}
			}
		}

		private static GameObject FindEnemyPrefab(string name, RoundManager m)
		{
			string value = name.Trim().ToLowerInvariant();
			List<SpawnableEnemyWithRarity> list = new List<SpawnableEnemyWithRarity>();
			if ((Object)(object)m.currentLevel != (Object)null)
			{
				if (m.currentLevel.Enemies != null)
				{
					list.AddRange(m.currentLevel.Enemies);
				}
				if (m.currentLevel.OutsideEnemies != null)
				{
					list.AddRange(m.currentLevel.OutsideEnemies);
				}
				if (m.currentLevel.DaytimeEnemies != null)
				{
					list.AddRange(m.currentLevel.DaytimeEnemies);
				}
			}
			foreach (SpawnableEnemyWithRarity item in list)
			{
				if ((Object)(object)item?.enemyType == (Object)null || !item.enemyType.enemyName.ToLowerInvariant().Contains(value))
				{
					continue;
				}
				return item.enemyType.enemyPrefab;
			}
			EnemyType[] array = Resources.FindObjectsOfTypeAll<EnemyType>();
			EnemyType[] array2 = array;
			foreach (EnemyType val in array2)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.enemyPrefab == (Object)null) && val.enemyName.ToLowerInvariant().Contains(value))
				{
					return val.enemyPrefab;
				}
			}
			return null;
		}

		private static Vector3 GetRandomOutsideNode(RoundManager m)
		{
			//IL_003e: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if (m.outsideAINodes == null || m.outsideAINodes.Length == 0)
			{
				return Vector3.zero;
			}
			int num = Random.Range(0, m.outsideAINodes.Length);
			return m.outsideAINodes[num].transform.position;
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Expected O, but got Unknown
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Expected O, but got Unknown
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Expected O, but got Unknown
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Expected O, but got Unknown
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Expected O, but got Unknown
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Expected O, but got Unknown
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Expected O, but got Unknown
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Expected O, but got Unknown
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Expected O, but got Unknown
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Expected O, but got Unknown
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Expected O, but got Unknown
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Expected O, but got Unknown
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Expected O, but got Unknown
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Expected O, but got Unknown
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Expected O, but got Unknown
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Expected O, but got Unknown
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Expected O, but got Unknown
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3666616739u, new RpcReceiveHandler(__rpc_handler_3666616739), "lightFlickerClientRpc");
			((NetworkBehaviour)this).__registerRpc(1533410096u, new RpcReceiveHandler(__rpc_handler_1533410096), "makePlayerDrunkClientRpc");
			((NetworkBehaviour)this).__registerRpc(2992081406u, new RpcReceiveHandler(__rpc_handler_2992081406), "timeJumpForwardClientRpc");
			((NetworkBehaviour)this).__registerRpc(3292847749u, new RpcReceiveHandler(__rpc_handler_3292847749), "notifyObungaClientRpc");
			((NetworkBehaviour)this).__registerRpc(529829256u, new RpcReceiveHandler(__rpc_handler_529829256), "notifyObungaLeftClientRpc");
			((NetworkBehaviour)this).__registerRpc(2694128158u, new RpcReceiveHandler(__rpc_handler_2694128158), "newRandomEventWarningClientRpc");
			((NetworkBehaviour)this).__registerRpc(1911799468u, new RpcReceiveHandler(__rpc_handler_1911799468), "timeJumpBackwardClientRpc");
			((NetworkBehaviour)this).__registerRpc(3590497892u, new RpcReceiveHandler(__rpc_handler_3590497892), "teleportPlayerClientRpc");
			((NetworkBehaviour)this).__registerRpc(3019070676u, new RpcReceiveHandler(__rpc_handler_3019070676), "fardClientRpc");
			((NetworkBehaviour)this).__registerRpc(1800866797u, new RpcReceiveHandler(__rpc_handler_1800866797), "burpClientRpc");
			((NetworkBehaviour)this).__registerRpc(3585418606u, new RpcReceiveHandler(__rpc_handler_3585418606), "squishClientRpc");
			((NetworkBehaviour)this).__registerRpc(2540607385u, new RpcReceiveHandler(__rpc_handler_2540607385), "expandClientRpc");
			((NetworkBehaviour)this).__registerRpc(857728355u, new RpcReceiveHandler(__rpc_handler_857728355), "medsClientRpc");
			((NetworkBehaviour)this).__registerRpc(2392522162u, new RpcReceiveHandler(__rpc_handler_2392522162), "stunClientRpc");
			((NetworkBehaviour)this).__registerRpc(1920748102u, new RpcReceiveHandler(__rpc_handler_1920748102), "randomSuitChangeClientRpc");
			((NetworkBehaviour)this).__registerRpc(2285070379u, new RpcReceiveHandler(__rpc_handler_2285070379), "spawnEggExplosionClientRpc");
			((NetworkBehaviour)this).__registerRpc(3729177168u, new RpcReceiveHandler(__rpc_handler_3729177168), "applyModifiersClientRpc");
			((NetworkBehaviour)this).__registerRpc(2351394233u, new RpcReceiveHandler(__rpc_handler_2351394233), "glitchHudClientRpc");
			((NetworkBehaviour)this).__registerRpc(2093172058u, new RpcReceiveHandler(__rpc_handler_2093172058), "radiationWarningHudClientRpc");
			((NetworkBehaviour)this).__registerRpc(2020295525u, new RpcReceiveHandler(__rpc_handler_2020295525), "shakeScreenClientRpc");
			((NetworkBehaviour)this).__registerRpc(1634251385u, new RpcReceiveHandler(__rpc_handler_1634251385), "spawnExplosionClientRpc");
			((NetworkBehaviour)this).__registerRpc(3426369828u, new RpcReceiveHandler(__rpc_handler_3426369828), "lightningStrikeClientRpc");
			((NetworkBehaviour)this).__registerRpc(588868959u, new RpcReceiveHandler(__rpc_handler_588868959), "bigBallsClientRpc");
			((NetworkBehaviour)this).__registerRpc(3732802136u, new RpcReceiveHandler(__rpc_handler_3732802136), "startPongGameClientRpc");
			((NetworkBehaviour)this).__registerRpc(2841350069u, new RpcReceiveHandler(__rpc_handler_2841350069), "startAmogusClientRpc");
			((NetworkBehaviour)this).__registerRpc(874795037u, new RpcReceiveHandler(__rpc_handler_874795037), "activateLadderClientRpc");
			((NetworkBehaviour)this).__registerRpc(2882102479u, new RpcReceiveHandler(__rpc_handler_2882102479), "picklefyClientRpc");
			((NetworkBehaviour)this).__registerRpc(3042755761u, new RpcReceiveHandler(__rpc_handler_3042755761), "setCreditsClientRpc");
			((NetworkBehaviour)this).__registerRpc(3232205781u, new RpcReceiveHandler(__rpc_handler_3232205781), "qsandClientRpc");
			((NetworkBehaviour)this).__registerRpc(2338797674u, new RpcReceiveHandler(__rpc_handler_2338797674), "completelyRandomSoundClientRpc");
			((NetworkBehaviour)this).__registerRpc(1053493706u, new RpcReceiveHandler(__rpc_handler_1053493706), "makeMissileClientRpc");
			((NetworkBehaviour)this).__registerRpc(3169009484u, new RpcReceiveHandler(__rpc_handler_3169009484), "startSuckClipClientRpc");
			((NetworkBehaviour)this).__registerRpc(3204882390u, new RpcReceiveHandler(__rpc_handler_3204882390), "toggleWeatherClientRpc");
			((NetworkBehaviour)this).__registerRpc(553391869u, new RpcReceiveHandler(__rpc_handler_553391869), "shipStretchClientRpc");
			((NetworkBehaviour)this).__registerRpc(3075557142u, new RpcReceiveHandler(__rpc_handler_3075557142), "pufferClientRpc");
			((NetworkBehaviour)this).__registerRpc(1159547838u, new RpcReceiveHandler(__rpc_handler_1159547838), "queueRandomEnemyBoltClientRpc");
			((NetworkBehaviour)this).__registerRpc(2086484989u, new RpcReceiveHandler(__rpc_handler_2086484989), "spawnMonsterServerRpc");
			((NetworkBehaviour)this).__registerRpc(572993813u, new RpcReceiveHandler(__rpc_handler_572993813), "spawnFailClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_3666616739(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;
				((LethalNet)(object)target).lightFlickerClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1533410096(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)
			{
				ulong playerid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).makePlayerDrunkClientRpc(playerid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2992081406(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;
				((LethalNet)(object)target).timeJumpForwardClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3292847749(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;
				((LethalNet)(object)target).notifyObungaClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_529829256(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;
				((LethalNet)(object)target).notifyObungaLeftClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2694128158(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 outcomeCount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref outcomeCount);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).newRandomEventWarningClientRpc(outcomeCount);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1911799468(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;
				((LethalNet)(object)target).timeJumpBackwardClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3590497892(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)
			{
				ulong playerid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerid);
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).teleportPlayerClientRpc(playerid, position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3019070676(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)
			{
				ulong playerid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).fardClientRpc(playerid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1800866797(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)
			{
				ulong playerid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).burpClientRpc(playerid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3585418606(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)
			{
				ulong playerid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).squishClientRpc(playerid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2540607385(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)
			{
				ulong playerid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).expandClientRpc(playerid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_857728355(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)
			{
				ulong playerid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).medsClientRpc(playerid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2392522162(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)
			{
				ulong playerid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).stunClientRpc(playerid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1920748102(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)
			{
				ulong playerid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).randomSuitChangeClientRpc(playerid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2285070379(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).spawnEggExplosionClientRpc(position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3729177168(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_004a: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				float jumpForce = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref jumpForce, default(ForPrimitives));
				float movementSpeed = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref movementSpeed, default(ForPrimitives));
				float playerReach = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref playerReach, default(ForPrimitives));
				bool fogEnabled = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref fogEnabled, default(ForPrimitives));
				float meanFreePath = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref meanFreePath, default(ForPrimitives));
				Color fogColor = default(Color);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref fogColor);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).applyModifiersClientRpc(jumpForce, movementSpeed, playerReach, fogEnabled, meanFreePath, fogColor);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2351394233(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;
				((LethalNet)(object)target).glitchHudClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2093172058(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;
				((LethalNet)(object)target).radiationWarningHudClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2020295525(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;
				((LethalNet)(object)target).shakeScreenClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1634251385(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).spawnExplosionClientRpc(position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3426369828(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).lightningStrikeClientRpc(position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_588868959(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)
			{
				ulong netid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref netid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).bigBallsClientRpc(netid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3732802136(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)
			{
				ulong netid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref netid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).startPongGameClientRpc(netid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2841350069(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)
			{
				ulong netid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref netid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).startAmogusClientRpc(netid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_874795037(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)
			{
				ulong netid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref netid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).activateLadderClientRpc(netid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2882102479(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).picklefyClientRpc(position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3042755761(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 creditsClientRpc = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref creditsClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).setCreditsClientRpc(creditsClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3232205781(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).qsandClientRpc(position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2338797674(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_006e: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).completelyRandomSoundClientRpc(name, position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1053493706(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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_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)
			{
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				Quaternion rotation = default(Quaternion);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref rotation);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).makeMissileClientRpc(pos, rotation);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3169009484(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;
				((LethalNet)(object)target).startSuckClipClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3204882390(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).toggleWeatherClientRpc(name);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_553391869(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 code = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref code);
				int time = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref time);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).shipStretchClientRpc(code, time);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3075557142(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).pufferClientRpc(position);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1159547838(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;
				((LethalNet)(object)target).queueRandomEnemyBoltClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2086484989(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string monsterName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref monsterName, false);
				}
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				bool useRandom = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref useRandom, default(ForPrimitives));
				ulong senderClientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref senderClientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).spawnMonsterServerRpc(monsterName, position, useRandom, senderClientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_572993813(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong targetClientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref targetClientId);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string reason = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref reason, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalNet)(object)target).spawnFailClientRpc(targetClientId, reason);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "LethalNet";
		}
	}
	public class MonsterSpawnerNet : NetworkBehaviour
	{
		[ServerRpc(RequireOwnership = false)]
		public void SpawnMonsterServerRpc(string monsterName, Vector3 position, bool useRandom, ulong senderClientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2828863818u, val, (RpcDelivery)0);
				bool flag = monsterName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(monsterName, false);
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref position);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref useRandom, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val2, senderClientId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2828863818u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			Debug.Log((object)$"[MonsterSpawnerNet] SpawnMonsterServerRpc received – monster='{monsterName}' useRandom={useRandom} sender={senderClientId}");
			RoundManager instance = RoundManager.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.currentLevel == (Object)null)
			{
				Debug.LogWarning((object)"[MonsterSpawnerNet] Spawn blocked – no moon loaded.");
				NotifyFailureClientRpc(senderClientId, "No moon loaded.");
				return;
			}
			Vector3 val3 = (useRandom ? GetRandomOutsidePosition(instance) : position);
			if (val3 == Vector3.zero)
			{
				Debug.LogWarning((object)"[MonsterSpawnerNet] Spawn blocked – could not resolve a valid position.");
				NotifyFailureClientRpc(senderClientId, "Could not find a valid spawn position.");
				return;
			}
			GameObject val4 = FindEnemyPrefab(monsterName, instance);
			if ((Object)(object)val4 == (Object)null)
			{
				Debug.LogWarning((object)("[MonsterSpawnerNet] No enemy found matching '" + monsterName + "'."));
				NotifyFailureClientRpc(senderClientId, "Enemy '" + monsterName + "' not found.");
				return;
			}
			try
			{
				GameObject val5 = Object.Instantiate<GameObject>(val4, val3, Quaternion.identity);
				NetworkObject componentInChildren = val5.GetComponentInChildren<NetworkObject>();
				if ((Object)(object)componentInChildren == (Object)null)
				{
					Debug.LogError((object)"[MonsterSpawnerNet] Spawned prefab has no NetworkObject!");
					Object.Destroy((Object)(object)val5);
					NotifyFailureClientRpc(senderClientId, "Prefab missing NetworkObject.");
					return;
				}
				componentInChildren.Spawn(true);
				EnemyAI component = val5.GetComponent<EnemyAI>();
				if ((Object)(object)component != (Object)null)
				{
					instance.SpawnedEnemies.Add(component);
					EnemyType enemyType = component.enemyType;
					enemyType.numberSpawned++;
				}
				EntityDestructionManager.destroyOnLeave.Add(val5);
				Debug.Log((object)$"[MonsterSpawnerNet] Spawned '{monsterName}' at {val3} (requested by client {senderClientId}).");
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[MonsterSpawnerNet] Spawn threw: {arg}");
				NotifyFailureClientRpc(senderClientId, "Exception during spawn – check logs.");
			}
		}

		[ClientRpc]
		private void NotifyFailureClientRpc(ulong targetClientId, string reason)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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_0095: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3856259424u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, targetClientId);
				bool flag = reason != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(reason, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3856259424u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (NetworkManager.Singleton.LocalClientId == targetClientId)
			{
				Debug.LogWarning((object)("[MonsterSpawnerNet] Spawn failed: " + reason));
				HUDManager instance = HUDManager.Instance;
				if (instance != null)
				{
					instance.DisplayTip("Monster Spawner", "Spawn failed: " + reason, true, false, "LC_Tip1");
				}
			}
		}

		private static GameObject FindEnemyPrefab(string name, RoundManager m)
		{
			string value = name.Trim().ToLowerInvariant();
			List<SpawnableEnemyWithRarity> list = new List<SpawnableEnemyWithRarity>();
			if ((Object)(object)m.currentLevel != (Object)null)
			{
				if (m.currentLevel.Enemies != null)
				{
					list.AddRange(m.currentLevel.Enemies);
				}
				if (m.currentLevel.OutsideEnemies != null)
				{
					list.AddRange(m.currentLevel.OutsideEnemies);
				}
				if (m.currentLevel.DaytimeEnemies != null)
				{
					list.AddRange(m.currentLevel.DaytimeEnemies);
				}
			}
			foreach (SpawnableEnemyWithRarity item in list)
			{
				if ((Object)(object)item?.enemyType == (Object)null || !item.enemyType.enemyName.ToLowerInvariant().Contains(value))
				{
					continue;
				}
				return item.enemyType.enemyPrefab;
			}
			EnemyType[] array = Resources.FindObjectsOfTypeAll<EnemyType>();
			EnemyType[] array2 = array;
			foreach (EnemyType val in array2)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.enemyPrefab == (Object)null) && val.enemyName.ToLowerInvariant().Contains(value))
				{
					return val.enemyPrefab;
				}
			}
			return null;
		}

		private static Vector3 GetRandomOutsidePosition(RoundManager m)
		{
			//IL_003e: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if (m.outsideAINodes == null || m.outsideAINodes.Length == 0)
			{
				return Vector3.zero;
			}
			int num = Random.Range(0, m.outsideAINodes.Length);
			return m.outsideAINodes[num].transform.position;
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2828863818u, new RpcReceiveHandler(__rpc_handler_2828863818), "SpawnMonsterServerRpc");
			((NetworkBehaviour)this).__registerRpc(3856259424u, new RpcReceiveHandler(__rpc_handler_3856259424), "NotifyFailureClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_2828863818(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string monsterName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref monsterName, false);
				}
				Vector3 position = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref position);
				bool useRandom = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref useRandom, default(ForPrimitives));
				ulong senderClientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref senderClientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((MonsterSpawnerNet)(object)target).SpawnMonsterServerRpc(monsterName, position, useRandom, senderClientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3856259424(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong targetClientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref targetClientId);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string reason = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref reason, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((MonsterSpawnerNet)(object)target).NotifyFailureClientRpc(targetClientId, reason);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "MonsterSpawnerNet";
		}
	}
}
namespace LethalChaos.EntropySystem.Hook_Sources
{
	internal class PlanetResetHook
	{
		public void linkEngineToScene()
		{
			if (EntropyEngine.moons.Length == 0)
			{
				EntropyEngine.LaunchEngine();
			}
			if (!((NetworkBehaviour)RoundManager.Instance).IsHost)
			{
				return;
			}
			try
			{
				if (Object.op_Implicit((Object)(object)Plugin.ChaosHost))
				{
					Debug.Log((object)"LethalChaos: Destroying Chaos Host (Networking)");
					Object.Destroy((Object)(object)Plugin.ChaosHost);
				}
				Plugin.ChaosHost = Object.Instantiate<GameObject>(Plugin.ChaosHostRef);
				Plugin.ChaosHost.GetComponent<NetworkObject>().Spawn(false);
				Plugin.rpcCalls = Plugin.ChaosHost.GetComponent<LethalNet>();
				Debug.Log((object)"LethalChaos: Created Chaos Host (Networking)");
			}
			catch (Exception ex)
			{
				Debug.LogError((object)ex);
			}
		}

		public PlanetResetHook()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			RoundManager.FinishGeneratingLevel += (hook_FinishGeneratingLevel)delegate(orig_FinishGeneratingLevel orig, RoundManager self)
			{
				orig.Invoke(self);
				WorldModifiers.fogChance = Plugin.fogChance.Value;
				EntropyEngine.LaunchEngine();
				entropyBlaster.meteorsToday = false;
				linkEngineToScene();
			};
			RoundManager.Start += (hook_Start)delegate(orig_Start orig, RoundManager self)
			{
				orig.Invoke(self);
				linkEngineToScene();
			};
			TimeOfDay.SetNewProfitQuota += (hook_SetNewProfitQuota)delegate(orig_SetNewProfitQuota orig, TimeOfDay self)
			{
				orig.Invoke(self);
				try
				{
					Debug.Log((object)"LethalChaos: Resetting Entropy Engine");
					linkEngineToScene();
				}
				catch (Exception ex)
				{
					Debug.LogError((object)ex);
				}
			};
		}
	}
}
namespace LethalChaos.EntropySystem.Util
{
	internal class EntityDestructionManager
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_ReviveDeadPlayers <>9__2_0;

			public static hook_DespawnPropsAtEndOfRound <>9__2_1;

			internal void <.ctor>b__2_0(orig_ReviveDeadPlayers orig, StartOfRound self)
			{
				orig.Invoke(self);
				Debug.Log((object)"Lethal Chaos: Destroying Spawned Items (ReviveDeadPlayers)");
				if (StartOfRound.Instance.allPlayersDead)
				{
					for (int i = 0; i < destroyOnFail.Count; i++)
					{
						Object.Destroy((Object)(object)destroyOnFail[i]);
					}
					destroyOnFail.Clear();
				}
				Accumulators.resetMults();
			}

			internal void <.ctor>b__2_1(orig_DespawnPropsAtEndOfRound orig, RoundManager self, bool despawnAllItems)
			{
				orig.Invoke(self, despawnAllItems);
				Debug.Log((object)"Lethal Chaos: Destroying Spawned Objects (LoadNewLevel)");
				for (int i = 0; i < destroyOnLeave.Count; i++)
				{
					Object.Destroy((Object)(object)destroyOnLeave[i]);
				}
				destroyOnLeave.Clear();
				Accumulators.resetMults();
			}
		}

		public static List<GameObject> destroyOnLeave = new List<GameObject>();

		public static List<GameObject> destroyOnFail = new List<GameObject>();

		public EntityDestructionManager()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			Debug.Log((object)"Lethal Chaos: Invoked Entity Destruction Manager");
			object obj = <>c.<>9__2_0;
			if (obj == null)
			{
				hook_ReviveDeadPlayers val = delegate(orig_ReviveDeadPlayers orig, StartOfRound self)
				{
					orig.Invoke(self);
					Debug.Log((object)"Lethal Chaos: Destroying Spawned Items (ReviveDeadPlayers)");
					if (StartOfRound.Instance.allPlayersDead)
					{
						for (int j = 0; j < destroyOnFail.Count; j++)
						{
							Object.Destroy((Object)(object)destroyOnFail[j]);
						}
						destroyOnFail.Clear();
					}
					Accumulators.resetMults();
				};
				<>c.<>9__2_0 = val;
				obj = (object)val;
			}
			StartOfRound.ReviveDeadPlayers += (hook_ReviveDeadPlayers)obj;
			object obj2 = <>c.<>9__2_1;
			if (obj2 == null)
			{
				hook_DespawnPropsAtEndOfRound val2 = delegate(orig_DespawnPropsAtEndOfRound orig, RoundManager self, bool despawnAllItems)
				{
					orig.Invoke(self, despawnAllItems);
					Debug.Log((object)"Lethal Chaos: Destroying Spawned Objects (LoadNewLevel)");
					for (int i = 0; i < destroyOnLeave.Count; i++)
					{
						Object.Destroy((Object)(object)destroyOnLeave[i]);
					}
					destroyOnLeave.Clear();
					Accumulators.resetMults();
				};
				<>c.<>9__2_1 = val2;
				obj2 = (object)val2;
			}
			RoundManager.DespawnPropsAtEndOfRound += (hook_DespawnPropsAtEndOfRound)obj2;
		}
	}
	public class Accumulators
	{
		public static float itemGetMult = 1f;

		public static float enemySpawnMult = 1f;

		public static float lightningSafetyMult = 1f;

		public static float explosionSafetyMult = 1f;

		public static int outcomeCounter = 0;

		public static void resetMults()
		{
			itemGetMult = 1f;
			enemySpawnMult = 1f;
			lightningSafetyMult = 1f;
			explosionSafetyMult = 1f;
			outcomeCounter = 0;
		}
	}
	public class EventThrottler
	{
		public static float summons;

		public static float objects;

		public static int[] triggerTotals;

		public EventThrottler()
		{
			triggerTotals = new int[EntropyHost.eventTotal];
			summons = 0f;
			objects = 0f;
		}

		public bool throttleGate(int eventid, int softcap, float objectWeight, float summonWeight)
		{
			softcap = (int)((float)softcap * Event.getUniqueMult(eventid));
			if (objects >= Plugin.maxObjectCount.Value && objectWeight > 0f)
			{
				Debug.Log((object)("Lethal Chaos: Event throttled - id: " + eventid + " objects: " + objects + " max objects: " + Plugin.maxObjectCount.Value));
				return true;
			}
			if (summons >= Plugin.maxMonsterCount.Value && summonWeight > 0f)
			{
				Debug.Log((object)("Lethal Chaos: Event throttled - id: " + eventid + " summons: " + summons + " max summons: " + Plugin.maxMonsterCount.Value));
				return true;
			}
			if (softcapGate(eventid, softcap))
			{
				Debug.Log((object)"Lethal Chaos: Event throttled - (softcap) ");
				return true;
			}
			objects += objectWeight;
			summons += summonWeight;
			return false;
		}

		private bool softcapGate(int eventid, int softcap)
		{
			int num = triggerTotals[eventid];
			if (num > softcap)
			{
				double num2 = EntropyEngine.rnd.NextDouble();
				double num3 = Math.Pow(num - softcap, 1.149999976158142) * (double)softcap;
				if (num2 > (double)softcap / num3)
				{
					Debug.Log((object)("Softcap throttle triggered: randomroll" + num2 + " timesTriggered" + num + " divisor: " + num3 + " softcap: " + softcap));
					return true;
				}
			}
			triggerTotals[eventid]++;
			return false;
		}
	}
	internal class ItemSubsetRandomizer
	{
		private List<int> options;

		private Random rnd;

		public ItemSubsetRandomizer(List<SpawnableItemWithRarity> spawnables, int seed)
		{
			rnd = new Random(seed);
			options = new List<int>();
			int num = (int)Math.Floor((double)rnd.Next(0, spawnables.Count) * Math.Pow(rnd.NextDouble(), 6.0) + 1.0);
			for (int i = 0; i < num; i++)
			{
				options.Add(rnd.Next(rnd.Next(0, spawnables.Count)));
			}
		}

		public int provideItemID()
		{
			return options[rnd.Next(0, options.Count)];
		}
	}
	internal class PresetSystem
	{
	}
	public class WorldModifiers
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_LoadNewLevel <>9__9_0;

			public static hook_FinishGeneratingNewLevelClientRpc <>9__9_1;

			internal void <Hooks>b__9_0(orig_LoadNewLevel orig, RoundManager self, int randomSeed, SelectableLevel newLevel)
			{
				orig.Invoke(self, randomSeed, newLevel);
				if (GameNetworkManager.Instance.isHostingGame)
				{
					Debug.Log((object)"Lethal Chaos: Applying Planet Modifiers as Host.");
					EntropyEngine.getMoonHost().modifiers.applyModifiers();
					EntropyEngine.getMoonHost().throttler = new EventThrottler();
				}
			}

			internal void <Hooks>b__9_1(orig_FinishGeneratingNewLevelClientRpc orig, RoundManager self)
			{
				orig.Invoke(self);
				if (!GameNetworkManager.Instance.isHostingGame)
				{
					Debug.Log((object)"Lethal Chaos: Synchronizing Planet Modifiers as Client.");
					EntropyEngine.getMoonHost().modifiers.applyModifiers();
				}
			}
		}

		private float chance = 0.1f;

		public static float fogChance = 0.2f;

		private Color fogColor = Random.ColorHSV(0f, 1f, 1f, 1f, 1f, 1f);

		private float meanFreePath = EntropyEngine.rnd.Next(10, 70);

		private bool fogEnabled = false;

		private float jumpForce = 12f;

		private float movementSpeed = 4.6f;

		private float playerReach = 3f;

		public WorldModifiers()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			fogChance = Plugin.fogChance.Value;
			if (EntropyEngine.rnd.NextDouble() < (double)fogChance)
			{
				Random.ColorHSV(0f, 1f, 1f, 1f, 0.5f, 1f);
				fogEnabled = true;
			}
			if (EntropyEngine.rnd.NextDouble() < (double)chance)
			{
				chance += 0.4f;
				if (EntropyEngine.rnd.NextDouble() <= 0.75)
				{
					playerReach = (float)(3.0 + EntropyEngine.rnd.NextDouble() * EntropyEngine.rnd.NextDouble() * 40.0);
				}
				else
				{
					playerReach = (float)(0.8 + 2.0 * EntropyEngine.rnd.NextDouble());
				}
			}
			if (EntropyEngine.rnd.NextDouble() < (double)chance)
			{
				chance += 0.4f;
				if (EntropyEngine.rnd.NextDouble() <= 0.75)
				{
					jumpForce = (float)(12.0 + EntropyEngine.rnd.NextDouble() * EntropyEngine.rnd.NextDouble() * 40.0);
				}
			}
			if (EntropyEngine.rnd.NextDouble() < (double)chance)
			{
				chance += 0.4f;
				if (EntropyEngine.rnd.NextDouble() <= 0.75)
				{
					movementSpeed = (float)(4.6 + EntropyEngine.rnd.NextDouble() * EntropyEngine.rnd.NextDouble() * EntropyEngine.rnd.NextDouble() * 20.0);
				}
			}
		}

		public static void Hooks()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			Debug.Log((object)"Lethal Chaos: Initializing WorldModifier hooks");
			object obj = <>c.<>9__9_0;
			if (obj == null)
			{
				hook_LoadNewLevel val = delegate(orig_LoadNewLevel orig, RoundManager self, int randomSeed, SelectableLevel newLevel)
				{
					orig.Invoke(self, randomSeed, newLevel);
					if (GameNetworkManager.Instance.isHostingGame)
					{
						Debug.Log((object)"Lethal Chaos: Applying Planet Modifiers as Host.");
						EntropyEngine.getMoonHost().modifiers.applyModifiers();
						EntropyEngine.getMoonHost().throttler = new EventThrottler();
					}
				};
				<>c.<>9__9_0 = val;
				obj = (object)val;
			}
			RoundManager.LoadNewLevel += (hook_LoadNewLevel)obj;
			object obj2 = <>c.<>9__9_1;
			if (obj2 == null)
			{
				hook_FinishGeneratingNewLevelClientRpc val2 = delegate(orig_FinishGeneratingNewLevelClientRpc orig, RoundManager self)
				{
					orig.Invoke(self);
					if (!GameNetworkManager.Instance.isHostingGame)
					{
						Debug.Log((object)"Lethal Chaos: Synchronizing Planet Modifiers as Client.");
						EntropyEngine.getMoonHost().modifiers.applyModifiers();
					}
				};
				<>c.<>9__9_1 = val2;
				obj2 = (object)val2;
			}
			RoundManager.FinishGeneratingNewLevelClientRpc += (hook_FinishGeneratingNewLevelClientRpc)obj2;
		}

		public void applyModifiers()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Plugin.rpcCalls.applyModifiersClientRpc(jumpForce, movementSpeed, playerReach, fogEnabled, meanFreePath, fogColor);
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace LethalChaos.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}