using System;
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 Andy.ShadyMod.NetcodePatcher;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using On.GameNetcodeStuff;
using ShadyMod.Model;
using ShadyMod.Network;
using ShadyMod.Perks;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;

[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("Andy.ShadyMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1+faf30ffc2d504e690ca22dd534e2cc9316f58cf2")]
[assembly: AssemblyProduct("ShadyMod")]
[assembly: AssemblyTitle("Andy.ShadyMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ShadyMod
{
	public static class Helper
	{
		private static readonly List<string> ignoreEnemies = new List<string>(2) { "FlowerSnakeEnemy", "DoublewingedBird" };

		public static string FormatVector3(this Vector3 vector3)
		{
			//IL_0006: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			return $"{vector3.x}|{vector3.y}|{vector3.z}";
		}

		public static bool GetRandomBoolean()
		{
			return Random.value > 0.5f;
		}

		public static List<EnemyAI> GetNearbyEnemys(Vector3 playerPos, float detectionRadius = 10f)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			List<EnemyAI> list = new List<EnemyAI>();
			foreach (KeyValuePair<ulong, NetworkObject> spawnedObject in NetworkManager.Singleton.SpawnManager.SpawnedObjects)
			{
				EnemyAI enemy = ((Component)spawnedObject.Value).GetComponent<EnemyAI>();
				if (!((Object)(object)enemy == (Object)null) && !enemy.isEnemyDead && !ignoreEnemies.Any((string e) => ((Object)enemy).name.Contains(e, StringComparison.OrdinalIgnoreCase)) && Vector3.Distance(playerPos, ((Component)enemy).transform.position) <= detectionRadius)
				{
					list.Add(enemy);
				}
			}
			return list;
		}

		public static void SendChatMessage(string chatMessage)
		{
			try
			{
				string item = "<color=#FF00FF>Shady</color>: <color=#FFFF00>" + chatMessage + "</color>";
				HUDManager.Instance.ChatMessageHistory.Add(item);
				UpdateChatText();
			}
			catch (Exception ex)
			{
				ShadyMod.Logger.LogError((object)("#### Failed to send chat message: " + ex.Message));
			}
		}

		public static void DisplayTooltip(string message)
		{
			HUDManager.Instance.DisplayTip("ShadyMod", message, false, false, "LC_Tip1");
		}

		private static void UpdateChatText()
		{
			((TMP_Text)HUDManager.Instance.chatText).text = string.Join("\n", HUDManager.Instance.ChatMessageHistory);
		}
	}
	[BepInPlugin("Andy.ShadyMod", "ShadyMod", "1.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class ShadyMod : BaseUnityPlugin
	{
		public static AssetBundle? assets = null;

		private bool isInitalized = false;

		private float defaultPlayerMovementSpeed = 0f;

		private Vector3 defaultPlayerScale = Vector3.zero;

		private Vector3 defaultCameraPos = Vector3.zero;

		private float defaultJumpForce = 0f;

		private bool lastPlayerActionPerformed = false;

		private const float teleportOffset = 0.5f;

		private static readonly Dictionary<string, string> SteamNameMapping = new Dictionary<string, string>
		{
			{ "belebt", "belebt" },
			{ "paul", "vette" },
			{ "lasse", "Lasse" },
			{ "aveloth", "aveloth" },
			{ "andy", "Andy" },
			{ "jedon", "JedonFT" },
			{ "patrick", "kxmischFxC" }
		};

		public static List<PerkBase> Perks = new List<PerkBase>();

		public static ShadyMod Instance { get; private set; } = null;


		internal static ManualLogSource Logger { get; private set; } = null;


		internal static Harmony? Harmony { get; set; }

		private void Awake()
		{
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Expected O, but got Unknown
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Expected O, but got Unknown
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Expected O, but got Unknown
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Expected O, but got Unknown
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Expected O, but got Unknown
			//IL_00fa: 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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: 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_016e: Unknown result type (might be due to invalid IL or missing references)
			NetcodePatcher();
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			Patch();
			assets = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "shady"));
			if ((Object)(object)assets == (Object)null)
			{
				Logger.LogError((object)"Failed to load custom assets.");
				return;
			}
			AssetInfo[] iNSTANCE = AssetInfo.INSTANCE;
			foreach (AssetInfo assetInfo in iNSTANCE)
			{
				Item val = assets.LoadAsset<Item>("Assets/AssetStore/shady/Items/" + assetInfo.Name + ".asset");
				if ((Object)(object)val != (Object)null)
				{
					Logger.LogDebug((object)$"#### Loading asset: {assetInfo.Name} with Rarity: {assetInfo.Rarity} ...");
					val.canBeGrabbedBeforeGameStart = true;
					if (assetInfo.IsHead)
					{
						val.rotationOffset = new Vector3(180f, 0f, 270f);
						val.positionOffset = new Vector3(0f, 0.322f, -0.2f);
					}
					else if (assetInfo.Name.Contains("donut", StringComparison.OrdinalIgnoreCase))
					{
						val.positionOffset = new Vector3(0f, 0.15f, -0.1f);
					}
					NetworkPrefabs.RegisterNetworkPrefab(val.spawnPrefab);
					Items.RegisterScrap(val, assetInfo.Rarity, assetInfo.Moons);
					Logger.LogInfo((object)("#### Asset " + assetInfo.Name + " successfully registered!"));
				}
				else
				{
					Logger.LogWarning((object)("#### Asset " + assetInfo.Name + " not found!"));
				}
			}
			PlayerControllerB.Update += new hook_Update(PlayerControllerB_Update);
			PlayerControllerB.BeginGrabObject += new hook_BeginGrabObject(PlayerControllerB_BeginGrabObject);
			PlayerControllerB.SwitchToItemSlot += new hook_SwitchToItemSlot(PlayerControllerB_SwitchToItemSlot);
			PlayerControllerB.ActivateItem_performed += new hook_ActivateItem_performed(PlayerControllerB_ActivateItem_performed);
			PlayerControllerB.DiscardHeldObject += new hook_DiscardHeldObject(PlayerControllerB_DiscardHeldObject);
			PlayerControllerB.DropAllHeldItems += new hook_DropAllHeldItems(PlayerControllerB_DropAllHeldItems);
			Logger.LogInfo((object)"#### Andy.ShadyMod v1.0.1 has loaded!");
		}

		private void PlayerControllerB_DropAllHeldItems(orig_DropAllHeldItems orig, PlayerControllerB self, bool itemsFall, bool disconnecting)
		{
			orig.Invoke(self, itemsFall, disconnecting);
			DisablePerks(self);
		}

		private void PlayerControllerB_DiscardHeldObject(orig_DiscardHeldObject orig, PlayerControllerB self, bool placeObject, NetworkObject parentObjectTo, Vector3 placePosition, bool matchRotationOfParent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, placeObject, parentObjectTo, placePosition, matchRotationOfParent);
			DisablePerks(self);
			lastPlayerActionPerformed = false;
		}

		private void PlayerControllerB_SwitchToItemSlot(orig_SwitchToItemSlot orig, PlayerControllerB self, int slot, GrabbableObject fillSlotWithItem)
		{
			orig.Invoke(self, slot, fillSlotWithItem);
			DisablePerks(self);
			EnablePerk(self.ItemSlots[slot], self);
		}

		private void PlayerControllerB_BeginGrabObject(orig_BeginGrabObject orig, PlayerControllerB self)
		{
			orig.Invoke(self);
			if (isInitalized)
			{
				GrabbableObject currentlyGrabbingObject = self.currentlyGrabbingObject;
				if ((Object)(object)currentlyGrabbingObject != (Object)null)
				{
					Logger.LogDebug((object)("#### Player grabbing an item: " + ((Object)currentlyGrabbingObject).name));
					EnablePerk(self.ItemSlots[self.currentItemSlot], self);
				}
			}
		}

		private void PlayerControllerB_Update(orig_Update orig, PlayerControllerB self)
		{
			//IL_002d: 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_004d: 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)
			//IL_005c: 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_0082: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (!isInitalized)
			{
				defaultPlayerMovementSpeed = self.movementSpeed;
				defaultPlayerScale = new Vector3(((Component)self).transform.localScale.x, ((Component)self).transform.localScale.y, ((Component)self).transform.localScale.z);
				defaultCameraPos = new Vector3(((Component)self.gameplayCamera).transform.localPosition.x, ((Component)self.gameplayCamera).transform.localPosition.y, ((Component)self.gameplayCamera).transform.localPosition.z);
				defaultJumpForce = self.jumpForce;
				Perks = new List<PerkBase>(7)
				{
					new SprintPerk(),
					new SpeedPerk(defaultPlayerMovementSpeed),
					new ScaleSmallPerk(defaultPlayerScale, defaultJumpForce, defaultCameraPos),
					new ScaleBigPerk(defaultPlayerScale, defaultJumpForce, defaultCameraPos),
					new EnemyKillPerk(),
					new EnemyStunnPerk(),
					new EnemySmallPerk()
				};
				isInitalized = true;
				Logger.LogInfo((object)"#### Shady Mod Initialization complemeted!");
				return;
			}
			GrabbableObject val = self.ItemSlots[self.currentItemSlot];
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			foreach (PerkBase perk in Perks)
			{
				if (perk.ShouldApply(self, val))
				{
					perk.OnUpdate(self);
				}
			}
		}

		private void PlayerControllerB_ActivateItem_performed(orig_ActivateItem_performed orig, PlayerControllerB self, CallbackContext context)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, context);
			if (!isInitalized || !(((CallbackContext)(ref context)).action.name == "ActivateItem"))
			{
				return;
			}
			GrabbableObject val = self.ItemSlots[self.currentItemSlot];
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if (lastPlayerActionPerformed)
			{
				Logger.LogDebug((object)"#### Player action is too fast! Ignoring ...");
				return;
			}
			lastPlayerActionPerformed = true;
			Logger.LogDebug((object)"#### Player action is valid! Processing ...");
			string itemSearchName = ((Object)val).name.ToLower().Replace("(clone)", string.Empty);
			Logger.LogDebug((object)("#### Item Search Name: " + itemSearchName));
			if (itemSearchName.Contains("donut"))
			{
				if (!StartOfRound.Instance.inShipPhase)
				{
					if (itemSearchName.Contains("bad"))
					{
						Helper.DisplayTooltip("That was a bad idea ...");
						self.DamagePlayerServerRpc(50, self.health - 50);
						self.MakeCriticallyInjuredServerRpc();
					}
					else
					{
						self.health = 100;
						self.healthRegenerateTimer = 0f;
						self.criticallyInjured = false;
						self.hasBeenCriticallyInjured = false;
						self.HealServerRpc();
					}
					DisablePerks(self);
					self.DestroyItemInSlotAndSync(self.currentItemSlot);
					lastPlayerActionPerformed = false;
				}
			}
			else
			{
				if (StartOfRound.Instance.inShipPhase || !AssetInfo.INSTANCE.Any((AssetInfo p) => p.Name.ToLower().Contains(itemSearchName) && p.IsHead))
				{
					return;
				}
				if (SteamNameMapping.ContainsKey(itemSearchName))
				{
					string text = SteamNameMapping[itemSearchName];
					bool flag = false;
					for (int i = 0; i < StartOfRound.Instance.allPlayerObjects.Length; i++)
					{
						PlayerControllerB val2 = StartOfRound.Instance.allPlayerScripts[i];
						if (!val2.playerUsername.Contains(text, StringComparison.OrdinalIgnoreCase) || val2.playerUsername == GameNetworkManager.Instance.localPlayerController.playerUsername)
						{
							continue;
						}
						Logger.LogDebug((object)("#### Player found: " + val2.playerUsername + " ..."));
						if (val2.isPlayerDead)
						{
							bool flag2 = true;
							if ((Object)(object)self.deadBody != (Object)null)
							{
								flag2 = Helper.GetRandomBoolean();
							}
							if (flag2)
							{
								self.KillPlayer(Vector3.zero, false, (CauseOfDeath)15, 0, default(Vector3));
							}
							else
							{
								Helper.DisplayTooltip("Lucky you! Maybe you can bring back the dead body!");
								HUDManager.Instance.ShakeCamera((ScreenShakeType)0);
								PerkNetworkHandler.Instance.TeleportPlayerOutServerRpc((int)self.playerClientId, new Vector3(val2.deadBody.spawnPosition.x + 0.5f, val2.deadBody.spawnPosition.y, val2.deadBody.spawnPosition.z + 0.5f));
								DisablePerks(self);
								lastPlayerActionPerformed = false;
							}
						}
						else
						{
							Logger.LogDebug((object)("#### Teleporting player " + val2.playerUsername));
							HUDManager.Instance.ShakeCamera((ScreenShakeType)0);
							PerkNetworkHandler.Instance.TeleportPlayerOutServerRpc((int)self.playerClientId, new Vector3(((Component)val2).transform.position.x + 0.5f, ((Component)((Component)val2).transform).transform.position.y, ((Component)val2).transform.position.z + 0.5f));
							DisablePerks(self);
							lastPlayerActionPerformed = false;
						}
						flag = true;
						break;
					}
					if (!flag)
					{
						Logger.LogWarning((object)("#### Target Player \"" + text + "\" not found to teleport to!"));
						Helper.DisplayTooltip("Bischt deppert? Target Player \"" + text + "\" not found to teleport to!");
						Helper.SendChatMessage(self.playerUsername + " ist deppert :(");
						DisablePerks(self);
						self.DestroyItemInSlotAndSync(self.currentItemSlot);
						lastPlayerActionPerformed = false;
						return;
					}
				}
				else
				{
					Logger.LogWarning((object)"#### Name-Mapping not found!");
				}
				self.DestroyItemInSlotAndSync(self.currentItemSlot);
				DisablePerks(self);
				lastPlayerActionPerformed = false;
			}
		}

		private void EnablePerk(GrabbableObject item, PlayerControllerB player)
		{
			PlayerControllerB player2 = player;
			GrabbableObject item2 = item;
			if ((Object)(object)item2 == (Object)null)
			{
				return;
			}
			Perks.ForEach(delegate(PerkBase p)
			{
				if (p.ShouldApply(player2, item2))
				{
					Logger.LogDebug((object)("[PERK]: Applying perk " + p.Name + " ..."));
					p.Apply(player2);
				}
			});
		}

		private void DisablePerks(PlayerControllerB player, bool force = false)
		{
			PlayerControllerB player2 = player;
			Logger.LogDebug((object)"[PERK]: Disabling all perks...");
			Perks.ForEach(delegate(PerkBase p)
			{
				p.Reset(player2, force);
			});
			lastPlayerActionPerformed = false;
		}

		internal static void Patch()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony = new Harmony("Andy.ShadyMod");
			}
			Logger.LogDebug((object)"Patching...");
			Harmony.PatchAll();
			Logger.LogDebug((object)"Finished patching!");
		}

		internal static void Unpatch()
		{
			Logger.LogDebug((object)"Unpatching...");
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			Logger.LogDebug((object)"Finished unpatching!");
		}

		private static void NetcodePatcher()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				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);
					}
				}
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Andy.ShadyMod";

		public const string PLUGIN_NAME = "ShadyMod";

		public const string PLUGIN_VERSION = "1.0.1";
	}
}
namespace ShadyMod.Perks
{
	public class EnemyKillPerk : PerkBase
	{
		public override string Name => "Enemy Kill";

		public override string Description => "Kills all nearby enemys";

		public override string TriggerItemName => "lasse";

		public override bool CanPerkBeIncreased => false;

		public override void OnUpdate(PlayerControllerB player)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			base.OnUpdate(player);
			if (StartOfRound.Instance.inShipPhase)
			{
				return;
			}
			List<EnemyAI> nearbyEnemys = Helper.GetNearbyEnemys(((Component)player).transform.position);
			if (nearbyEnemys.Count <= 0)
			{
				return;
			}
			bool flag = false;
			List<string> list = new List<string>();
			foreach (EnemyAI item in nearbyEnemys)
			{
				ShadyMod.Logger.LogDebug((object)("#### Killing nearby enemy " + ((Object)item).name + " ..."));
				player.movementAudio.PlayOneShot(item.dieSFX);
				item.KillEnemy(false);
				list.Add(((Object)item).name.Replace("(Clone)", string.Empty).Replace("(clone)", string.Empty));
				flag = true;
			}
			if (flag)
			{
				Helper.DisplayTooltip("Great job! You killed " + string.Join(", ", list) + "!");
				player.DestroyItemInSlotAndSync(player.currentItemSlot);
			}
		}
	}
	public class EnemySmallPerk : PerkBase
	{
		public override string Name => "Enemy Small Perk";

		public override string Description => "Scales all nearby enemies small";

		public override string TriggerItemName => "patrick";

		public override bool CanPerkBeIncreased => false;

		public override void OnUpdate(PlayerControllerB player)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			base.OnUpdate(player);
			if (StartOfRound.Instance.inShipPhase)
			{
				return;
			}
			List<EnemyAI> nearbyEnemys = Helper.GetNearbyEnemys(((Component)player).transform.position);
			if (nearbyEnemys.Count <= 0)
			{
				return;
			}
			bool flag = false;
			foreach (EnemyAI item in nearbyEnemys)
			{
				ShadyMod.Logger.LogDebug((object)("#### Scaling enemy small: " + ((Object)item).name + " ..."));
				float num = 0.5f;
				if (((Object)item).name.Contains("ForestGiant", StringComparison.OrdinalIgnoreCase))
				{
					num = 0.15f;
				}
				((Component)item).transform.localScale = new Vector3(num, num, num);
			}
			if (flag)
			{
				player.DestroyItemInSlotAndSync(player.currentItemSlot);
			}
		}
	}
	public class EnemyStunnPerk : PerkBase
	{
		public override string Name => "Enemy Stunn Perk";

		public override string Description => "Stunns all nearby enemies for 30 seconds";

		public override string TriggerItemName => "jedon";

		public override bool CanPerkBeIncreased => true;

		public override void OnUpdate(PlayerControllerB player)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			base.OnUpdate(player);
			if (StartOfRound.Instance.inShipPhase)
			{
				return;
			}
			List<EnemyAI> nearbyEnemys = Helper.GetNearbyEnemys(((Component)player).transform.position);
			if (nearbyEnemys.Count <= 0)
			{
				return;
			}
			bool flag = false;
			foreach (EnemyAI item in nearbyEnemys)
			{
				if (!((Object)(object)item.stunnedByPlayer != (Object)null) || !(item.stunnedByPlayer.playerUsername == player.playerUsername))
				{
					ShadyMod.Logger.LogDebug((object)("#### Stunning nearby enemy " + ((Object)item).name + " ..."));
					player.movementAudio.PlayOneShot(item.dieSFX);
					int num = 10;
					if (ShouldIncreasePerk(player))
					{
						num = 30;
					}
					item.SetEnemyStunned(true, (float)num, player);
					flag = true;
				}
			}
			if (flag)
			{
				Helper.DisplayTooltip("You scared the enemys, time to leave (be fast)!");
				player.DestroyItemInSlotAndSync(player.currentItemSlot);
			}
		}
	}
	public abstract class PerkBase
	{
		protected bool isApplied = false;

		public abstract string Name { get; }

		public abstract string Description { get; }

		public abstract string TriggerItemName { get; }

		public abstract bool CanPerkBeIncreased { get; }

		public virtual void Apply(PlayerControllerB player, bool force = false)
		{
			if (CanPerkBeIncreased && ShouldIncreasePerk(player))
			{
				Helper.DisplayTooltip("Your own head? Great! Your perk will be increased!");
			}
		}

		public virtual void Reset(PlayerControllerB player, bool force = false)
		{
		}

		public virtual void OnUpdate(PlayerControllerB player)
		{
		}

		public virtual bool ShouldApply(PlayerControllerB player, GrabbableObject item)
		{
			return ((Object)item).name.Contains(TriggerItemName);
		}

		public virtual bool ShouldIncreasePerk(PlayerControllerB player)
		{
			return ((Object)player).name.Contains(TriggerItemName, StringComparison.OrdinalIgnoreCase);
		}
	}
	public class ScaleSmallPerk : PerkBase
	{
		private const float playerJumpForce = 6f;

		private const float playerScale = 0.5f;

		private readonly Vector3 defaultPlayerScale = Vector3.zero;

		private readonly float defaultPlayerJumpForce = 0f;

		private readonly Vector3 defaultCameraPos = Vector3.zero;

		public override string Name => "Scale Small Perk";

		public override string Description => "Small crewmate (really smol)";

		public override string TriggerItemName => "paul";

		public override bool CanPerkBeIncreased => true;

		public ScaleSmallPerk(Vector3 playerScaleDefault, float playerJumpForceDefault, Vector3 defaultCameraPos)
		{
			//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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_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)
			defaultPlayerScale = playerScaleDefault;
			defaultPlayerJumpForce = playerJumpForceDefault;
			this.defaultCameraPos = defaultCameraPos;
		}

		public override void Apply(PlayerControllerB player, bool force = false)
		{
			//IL_0075: 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)
			base.Apply(player);
			if (force || !isApplied)
			{
				float num = 0.5f;
				float num2 = 6f;
				if (ShouldIncreasePerk(player))
				{
					num = 0.4f;
					num2 -= 1f;
				}
				if (!force)
				{
					Helper.SendChatMessage(player.playerUsername + " einfach kleinste Spieler!");
				}
				((Component)player).transform.localScale = new Vector3(num, num, num);
				((Component)player.gameplayCamera).transform.localPosition = new Vector3(0f, num, 0f);
				player.jumpForce = num2;
				if (!force)
				{
					NetworkMessage networkMessage = new NetworkMessage
					{
						PlayerName = player.playerUsername,
						Action = "apply",
						PerkName = Name,
						PlayerId = player.actualClientId
					};
					PerkNetworkHandler.Instance.EventServerRpc(networkMessage.ToString());
				}
				if (!force)
				{
					isApplied = true;
				}
			}
		}

		public override void Reset(PlayerControllerB player, bool force = false)
		{
			//IL_002d: 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)
			if (force || isApplied)
			{
				base.Reset(player);
				((Component)player).transform.localScale = defaultPlayerScale;
				((Component)player.gameplayCamera).transform.localPosition = defaultCameraPos;
				player.jumpForce = defaultPlayerJumpForce;
				if (!force)
				{
					NetworkMessage networkMessage = new NetworkMessage
					{
						PlayerName = player.playerUsername,
						Action = "reset",
						PerkName = Name,
						PlayerId = player.actualClientId
					};
					PerkNetworkHandler.Instance.EventServerRpc(networkMessage.ToString());
				}
				if (!force)
				{
					isApplied = false;
				}
			}
		}
	}
	public class ScaleBigPerk : PerkBase
	{
		private const float playerJumpForce = 20f;

		private const float playerScale = 1.25f;

		private readonly Vector3 defaultPlayerScale = Vector3.zero;

		private readonly float defaultPlayerJumpForce = 0f;

		private readonly Vector3 defaultCameraPos = Vector3.zero;

		public override string Name => "Scale Big Perk";

		public override string Description => "Big crewmate (fr)";

		public override string TriggerItemName => "aveloth";

		public override bool CanPerkBeIncreased => true;

		public ScaleBigPerk(Vector3 playerScaleDefault, float playerJumpForceDefault, Vector3 defaultCameraPos)
		{
			//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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_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)
			defaultPlayerScale = playerScaleDefault;
			defaultPlayerJumpForce = playerJumpForceDefault;
			this.defaultCameraPos = defaultCameraPos;
		}

		public override void Apply(PlayerControllerB player, bool force = false)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if (force || !isApplied)
			{
				base.Apply(player);
				float num = 1.25f;
				float num2 = 20f;
				if (ShouldIncreasePerk(player))
				{
					num += 0.5f;
					num2 += 2f;
				}
				((Component)player).transform.localScale = new Vector3(num, num, num);
				((Component)player.gameplayCamera).transform.localPosition = new Vector3(0f, num, 0f);
				player.jumpForce = num2;
				if (!force)
				{
					NetworkMessage networkMessage = new NetworkMessage
					{
						PlayerName = player.playerUsername,
						Action = "apply",
						PerkName = Name,
						PlayerId = player.actualClientId
					};
					PerkNetworkHandler.Instance.EventServerRpc(networkMessage.ToString());
				}
				if (!force)
				{
					isApplied = true;
				}
			}
		}

		public override void Reset(PlayerControllerB player, bool force = false)
		{
			//IL_002d: 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)
			if (force || isApplied)
			{
				base.Reset(player);
				((Component)player).transform.localScale = defaultPlayerScale;
				((Component)player.gameplayCamera).transform.localPosition = defaultCameraPos;
				player.jumpForce = defaultPlayerJumpForce;
				if (!force)
				{
					NetworkMessage networkMessage = new NetworkMessage
					{
						PlayerName = player.playerUsername,
						Action = "reset",
						PerkName = Name,
						PlayerId = player.actualClientId
					};
					PerkNetworkHandler.Instance.EventServerRpc(networkMessage.ToString());
				}
				if (!force)
				{
					isApplied = false;
				}
			}
		}
	}
	public class SpeedPerk : PerkBase
	{
		private const float playerMovementSpeedPerk = 10f;

		private const float movementIncrease = 5f;

		private readonly float defaultMovementSpeed = 0f;

		public override string Name => "Speed Perk";

		public override string Description => "The player moves faster than normal";

		public override string TriggerItemName => "belebt";

		public override bool CanPerkBeIncreased => true;

		public SpeedPerk(float defaultMovementSpeed)
		{
			this.defaultMovementSpeed = defaultMovementSpeed;
		}

		public override void Apply(PlayerControllerB player, bool force = false)
		{
			if (!force && isApplied)
			{
				return;
			}
			base.Apply(player);
			player.movementSpeed = 10f;
			if (ShouldIncreasePerk(player))
			{
				player.movementSpeed += 5f;
			}
			if (!force)
			{
				if (player.playerUsername.Contains("belebt", StringComparison.OrdinalIgnoreCase))
				{
					Helper.SendChatMessage("belebt einfach schneller als Elytra, Wahnsinn (◡\u203f◡)");
				}
				else
				{
					Helper.SendChatMessage(player.playerUsername + " einfach schnellste(r)");
				}
			}
			if (!force)
			{
				isApplied = true;
			}
		}

		public override void Reset(PlayerControllerB player, bool force = false)
		{
			if (force || isApplied)
			{
				base.Reset(player);
				player.movementSpeed = defaultMovementSpeed;
				if (!force)
				{
					isApplied = false;
				}
			}
		}
	}
	public class SprintPerk : PerkBase
	{
		public override string Name => "Sprint Perk";

		public override string Description => "Endless stamina";

		public override string TriggerItemName => "andy";

		public override bool CanPerkBeIncreased => false;

		public override void OnUpdate(PlayerControllerB player)
		{
			base.OnUpdate(player);
			player.sprintMeter = 1f;
		}
	}
}
namespace ShadyMod.Patches
{
	[HarmonyPatch]
	public class NetworkObjectManager
	{
		private static GameObject networkPrefab;

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		public static void Init()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			if (!((Object)(object)networkPrefab != (Object)null))
			{
				networkPrefab = (GameObject)ShadyMod.assets.LoadAsset("PerkNetworkHandler");
				networkPrefab.AddComponent<PerkNetworkHandler>();
				NetworkManager.Singleton.AddNetworkPrefab(networkPrefab);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		private static void SpawnNetworkHandler()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
			{
				GameObject val = Object.Instantiate<GameObject>(networkPrefab, Vector3.zero, Quaternion.identity);
				val.GetComponent<NetworkObject>().Spawn(false);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		private static void SubscribeToHandler()
		{
			PerkNetworkHandler.MessageEvent += ReceivedEventFromServer;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(RoundManager), "DespawnPropsAtEndOfRound")]
		private static void UnsubscribeFromHandler()
		{
			PerkNetworkHandler.MessageEvent -= ReceivedEventFromServer;
		}

		private static void ReceivedEventFromServer(string json)
		{
			Debug.Log((object)("Recieved event from server: " + json));
			NetworkMessage nm = JsonConvert.DeserializeObject<NetworkMessage>(json);
			if (nm == null)
			{
				return;
			}
			Debug.Log((object)("Action to execute is: " + nm.Action));
			foreach (KeyValuePair<ulong, NetworkObject> spawnedObject in NetworkManager.Singleton.SpawnManager.SpawnedObjects)
			{
				PlayerControllerB component = ((Component)spawnedObject.Value).GetComponent<PlayerControllerB>();
				if (!((Object)(object)component != (Object)null) || !(component.playerUsername == nm.PlayerName))
				{
					continue;
				}
				Debug.Log((object)("#### Player found: " + component.playerUsername));
				PerkBase perkBase = ShadyMod.Perks.FirstOrDefault((PerkBase p) => p.Name == nm.PerkName);
				if (perkBase == null)
				{
					break;
				}
				string action = nm.Action;
				string text = action;
				if (!(text == "apply"))
				{
					if (text == "reset")
					{
						perkBase.Reset(component, force: true);
					}
				}
				else
				{
					perkBase.Apply(component, force: true);
				}
			}
		}

		public static void SendEventToClients(string eventName)
		{
			if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
			{
				PerkNetworkHandler.Instance.EventClientRpc(eventName);
			}
		}
	}
}
namespace ShadyMod.Network
{
	public class PerkNetworkHandler : NetworkBehaviour
	{
		public static PerkNetworkHandler Instance { get; private set; }

		public static event Action<string>? MessageEvent;

		public override void OnNetworkSpawn()
		{
			PerkNetworkHandler.MessageEvent = null;
			if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
			{
				PerkNetworkHandler instance = Instance;
				if (instance != null)
				{
					GameObject gameObject = ((Component)instance).gameObject;
					if (gameObject != null)
					{
						NetworkObject component = gameObject.GetComponent<NetworkObject>();
						if (component != null)
						{
							component.Despawn(true);
						}
					}
				}
			}
			Instance = this;
			((NetworkBehaviour)this).OnNetworkSpawn();
		}

		[ClientRpc]
		public void EventClientRpc(string eventName)
		{
			//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_00ba: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2030828849u, val, (RpcDelivery)0);
				bool flag = eventName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(eventName, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2030828849u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				PerkNetworkHandler.MessageEvent?.Invoke(eventName);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void EventServerRpc(string eventName)
		{
			//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_00ba: 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(1747992973u, val, (RpcDelivery)0);
				bool flag = eventName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(eventName, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1747992973u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				EventClientRpc(eventName);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void TeleportPlayerOutServerRpc(int playerObj, Vector3 teleportPos)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4246910149u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerObj);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref teleportPos);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4246910149u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					TeleportPlayerOutClientRpc(playerObj, teleportPos);
				}
			}
		}

		[ClientRpc]
		public void TeleportPlayerOutClientRpc(int playerObj, Vector3 teleportPos)
		{
			//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_00e5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2810027324u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerObj);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref teleportPos);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2810027324u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[playerObj];
					val3.TeleportPlayer(teleportPos, false, 0f, false, true);
				}
			}
		}

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

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_PerkNetworkHandler()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(2030828849u, new RpcReceiveHandler(__rpc_handler_2030828849));
			NetworkManager.__rpc_func_table.Add(1747992973u, new RpcReceiveHandler(__rpc_handler_1747992973));
			NetworkManager.__rpc_func_table.Add(4246910149u, new RpcReceiveHandler(__rpc_handler_4246910149));
			NetworkManager.__rpc_func_table.Add(2810027324u, new RpcReceiveHandler(__rpc_handler_2810027324));
		}

		private static void __rpc_handler_2030828849(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 eventName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref eventName, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((PerkNetworkHandler)(object)target).EventClientRpc(eventName);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1747992973(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 eventName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref eventName, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PerkNetworkHandler)(object)target).EventServerRpc(eventName);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4246910149(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerObj = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerObj);
				Vector3 teleportPos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref teleportPos);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PerkNetworkHandler)(object)target).TeleportPlayerOutServerRpc(playerObj, teleportPos);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2810027324(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerObj = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerObj);
				Vector3 teleportPos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref teleportPos);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((PerkNetworkHandler)(object)target).TeleportPlayerOutClientRpc(playerObj, teleportPos);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "PerkNetworkHandler";
		}
	}
}
namespace ShadyMod.Model
{
	public class AssetInfo
	{
		public static readonly AssetInfo[] INSTANCE = new AssetInfo[12]
		{
			new AssetInfo
			{
				Moons = (LevelTypes)(-1),
				Name = "head-belebt",
				IsHead = true,
				Rarity = 40
			},
			new AssetInfo
			{
				Moons = (LevelTypes)(-1),
				Name = "head-paul",
				IsHead = true,
				Rarity = 40
			},
			new AssetInfo
			{
				Moons = (LevelTypes)(-1),
				Name = "head-lasse",
				IsHead = true,
				Rarity = 40
			},
			new AssetInfo
			{
				Moons = (LevelTypes)(-1),
				Name = "head-aveloth",
				IsHead = true,
				Rarity = 40
			},
			new AssetInfo
			{
				Moons = (LevelTypes)(-1),
				Name = "head-andy",
				IsHead = true,
				Rarity = 40
			},
			new AssetInfo
			{
				Moons = (LevelTypes)(-1),
				Name = "head-jedon",
				IsHead = true,
				Rarity = 40
			},
			new AssetInfo
			{
				Moons = (LevelTypes)(-1),
				Name = "head-patrick",
				IsHead = true,
				Rarity = 40
			},
			new AssetInfo
			{
				Moons = (LevelTypes)(-1),
				Name = "donut",
				Rarity = 69
			},
			new AssetInfo
			{
				Moons = (LevelTypes)(-1),
				Name = "bad-donut",
				Rarity = 69
			},
			new AssetInfo
			{
				Moons = (LevelTypes)(-1),
				Name = "weight",
				Rarity = 70
			},
			new AssetInfo
			{
				Moons = (LevelTypes)(-1),
				Name = "shadydoc1",
				Rarity = 30
			},
			new AssetInfo
			{
				Moons = (LevelTypes)(-1),
				Name = "shadydoc2",
				Rarity = 30
			}
		};

		public string Name { get; set; } = string.Empty;


		public int Rarity { get; set; } = 0;


		public bool IsHead { get; set; }

		public LevelTypes Moons { get; set; } = (LevelTypes)(-1);

	}
	public class NetworkMessage
	{
		public ulong PlayerId { get; set; } = 0uL;


		public string PlayerName { get; set; } = string.Empty;


		public string Action { get; set; } = string.Empty;


		public string PerkName { get; set; } = string.Empty;


		public override string ToString()
		{
			return JsonConvert.SerializeObject((object)this, (Formatting)0);
		}
	}
}
namespace Andy.ShadyMod.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}