using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using DontTouchMyClogs;
using GameNetcodeStuff;
using HarmonyLib;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Video;
using com.github.zehsteam.DontTouchMyClogs;
using com.github.zehsteam.DontTouchMyClogs.MonoBehaviours;
using com.github.zehsteam.DontTouchMyClogs.NetcodePatcher;

[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("com.github.zehsteam.DontTouchMyClogs")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Don't touch my clogs!")]
[assembly: AssemblyFileVersion("1.0.2.0")]
[assembly: AssemblyInformationalVersion("1.0.2+b88df8f2c50f22471de78a4fb6ca452826f49cf6")]
[assembly: AssemblyProduct("DontTouchMyClogs")]
[assembly: AssemblyTitle("com.github.zehsteam.DontTouchMyClogs")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
		NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<bool>();
		NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<bool>();
	}
}
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;
		}
	}
}
namespace DontTouchMyClogs
{
	[BepInPlugin("com.github.zehsteam.DontTouchMyClogs", "DontTouchMyClogs", "1.0.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private readonly Harmony harmony = new Harmony("com.github.zehsteam.DontTouchMyClogs");

		internal static Plugin Instance;

		internal static ManualLogSource logger;

		internal static ConfigManager ConfigManager;

		public static bool IsHostOrServer => NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			logger = Logger.CreateLogSource("com.github.zehsteam.DontTouchMyClogs");
			logger.LogInfo((object)"DontTouchMyClogs has awoken!");
			ConfigManager = new ConfigManager();
			Content.Load();
			RegisterScrapItems();
			NetcodePatcherAwake();
		}

		private void NetcodePatcherAwake()
		{
			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);
					}
				}
			}
		}

		private void RegisterScrapItems()
		{
			int spawnWeight = ConfigManager.SpawnWeight;
			bool twoHanded = ConfigManager.TwoHanded;
			int carryWeight = ConfigManager.CarryWeight;
			int minValue = ConfigManager.MinValue;
			int maxValue = ConfigManager.MaxValue;
			ScrapHelper.RegisterScrap(Content.woodenClogs, spawnWeight, twoHanded, carryWeight, minValue, maxValue);
		}

		public void SpawnVideoPlayer()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)VideoPlayerBehaviour.Instance != (Object)null))
			{
				Object.Instantiate<GameObject>(Content.videoPlayerPrefab, Vector3.zero, Quaternion.identity);
				logger.LogInfo((object)"Spawned video player.");
			}
		}
	}
}
namespace com.github.zehsteam.DontTouchMyClogs
{
	internal class ConfigManager
	{
		private ConfigEntry<int> SpawnWeightCfg;

		private ConfigEntry<bool> TwoHandedCfg;

		private ConfigEntry<int> CarryWeightCfg;

		private ConfigEntry<int> MinValueCfg;

		private ConfigEntry<int> MaxValueCfg;

		private ConfigEntry<float> VideoVolumeCfg;

		private ConfigEntry<bool> EnableMusicCfg;

		private ConfigEntry<float> MusicVolumeCfg;

		internal int SpawnWeight
		{
			get
			{
				return SpawnWeightCfg.Value;
			}
			set
			{
				SpawnWeightCfg.Value = value;
			}
		}

		internal bool TwoHanded
		{
			get
			{
				return TwoHandedCfg.Value;
			}
			set
			{
				TwoHandedCfg.Value = value;
			}
		}

		internal int CarryWeight
		{
			get
			{
				return CarryWeightCfg.Value;
			}
			set
			{
				CarryWeightCfg.Value = value;
			}
		}

		internal int MinValue
		{
			get
			{
				return MinValueCfg.Value;
			}
			set
			{
				MinValueCfg.Value = value;
			}
		}

		internal int MaxValue
		{
			get
			{
				return MaxValueCfg.Value;
			}
			set
			{
				MaxValueCfg.Value = value;
			}
		}

		internal float VideoVolume
		{
			get
			{
				return VideoVolumeCfg.Value;
			}
			set
			{
				VideoVolumeCfg.Value = value;
			}
		}

		internal bool EnableMusic
		{
			get
			{
				return EnableMusicCfg.Value;
			}
			set
			{
				EnableMusicCfg.Value = value;
			}
		}

		internal float MusicVolume
		{
			get
			{
				return MusicVolumeCfg.Value;
			}
			set
			{
				MusicVolumeCfg.Value = value;
			}
		}

		public ConfigManager()
		{
			BindConfigs();
			ClearUnusedEntries();
		}

		private void BindConfigs()
		{
			//IL_0018: 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_003a: Expected O, but got Unknown
			//IL_003a: Expected O, but got Unknown
			//IL_004b: 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_0066: Expected O, but got Unknown
			//IL_0066: Expected O, but got Unknown
			//IL_0077: 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_0093: Expected O, but got Unknown
			//IL_0093: Expected O, but got Unknown
			//IL_00a4: 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_00c0: Expected O, but got Unknown
			//IL_00c0: Expected O, but got Unknown
			//IL_00d1: 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_00f0: Expected O, but got Unknown
			//IL_00f0: Expected O, but got Unknown
			//IL_0101: 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_0120: Expected O, but got Unknown
			//IL_0120: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			//IL_014c: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Expected O, but got Unknown
			//IL_017c: Expected O, but got Unknown
			ConfigFile config = ((BaseUnityPlugin)Plugin.Instance).Config;
			SpawnWeightCfg = config.Bind<int>(new ConfigDefinition("General Settings", "SpawnWeight"), 5, new ConfigDescription("Wooden Clogs spawn chance weight. higher = more common.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			TwoHandedCfg = config.Bind<bool>(new ConfigDefinition("General Settings", "TwoHanded"), false, new ConfigDescription("If enabled, the Wooden Clogs will be two-handed.", (AcceptableValueBase)null, Array.Empty<object>()));
			CarryWeightCfg = config.Bind<int>(new ConfigDefinition("General Settings", "CarryWeight"), 10, new ConfigDescription("Wooden Clogs carry weight in pounds.", (AcceptableValueBase)null, Array.Empty<object>()));
			MinValueCfg = config.Bind<int>(new ConfigDefinition("General Settings", "MinValue"), 80, new ConfigDescription("Wooden Clogs min scrap value.", (AcceptableValueBase)null, Array.Empty<object>()));
			MaxValueCfg = config.Bind<int>(new ConfigDefinition("General Settings", "MaxValue"), 250, new ConfigDescription("Wooden Clogs max scrap value.", (AcceptableValueBase)null, Array.Empty<object>()));
			VideoVolumeCfg = config.Bind<float>(new ConfigDefinition("Karaoke Settings", "VideoVolume"), 0.75f, new ConfigDescription("The volume of the karaoke video. (0.0 to 1.0)", (AcceptableValueBase)null, Array.Empty<object>()));
			EnableMusicCfg = config.Bind<bool>(new ConfigDefinition("Music Settings", "EnableMusic"), false, new ConfigDescription("STREAMER WARNING! Music is DMCA.\nIf enabled, the music will be play. (This does not affect Karaoke)", (AcceptableValueBase)null, Array.Empty<object>()));
			MusicVolumeCfg = config.Bind<float>(new ConfigDefinition("Music Settings", "MusicVolume"), 1f, new ConfigDescription("The volume of the music. (0.0 to 1.0)", (AcceptableValueBase)null, Array.Empty<object>()));
		}

		private void ClearUnusedEntries()
		{
			ConfigFile config = ((BaseUnityPlugin)Plugin.Instance).Config;
			PropertyInfo property = ((object)config).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
			Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)property.GetValue(config, null);
			dictionary.Clear();
			config.Save();
		}
	}
	internal class Content
	{
		public static Item woodenClogs;

		public static GameObject videoPlayerPrefab;

		public static void Load()
		{
			LoadAssetsFromAssetBundle();
		}

		private static void LoadAssetsFromAssetBundle()
		{
			try
			{
				string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location);
				string text = Path.Combine(directoryName, "donttouchmyclogs_assets");
				AssetBundle val = AssetBundle.LoadFromFile(text);
				woodenClogs = val.LoadAsset<Item>("WoodenClogs");
				videoPlayerPrefab = val.LoadAsset<GameObject>("VideoPlayer");
				Plugin.logger.LogInfo((object)"Successfully loaded assets from AssetBundle!");
			}
			catch (Exception arg)
			{
				Plugin.logger.LogError((object)$"Error: failed to load assets from AssetBundle.\n\n{arg}");
			}
		}
	}
	internal class ScrapHelper
	{
		public static void RegisterScrap(Item item, int iRarity, bool twoHanded, int carryWeight, int minValue, int maxValue)
		{
			item.twoHanded = twoHanded;
			item.weight = (float)carryWeight / 105f + 1f;
			item.minValue = minValue;
			item.maxValue = maxValue;
			Utilities.FixMixerGroups(item.spawnPrefab);
			NetworkPrefabs.RegisterNetworkPrefab(item.spawnPrefab);
			Items.RegisterScrap(item, iRarity, (LevelTypes)(-1));
			Plugin.logger.LogInfo((object)$"Registered \"{item.itemName}\" scrap item with {iRarity} rarity.");
		}
	}
	internal class Utils
	{
		public static PlayerControllerB GetLocalPlayerScript()
		{
			return GameNetworkManager.Instance.localPlayerController;
		}

		public static void DisplayNotification(string displayText)
		{
			HUDManager.Instance.globalNotificationAnimator.SetTrigger("TriggerNotif");
			((TMP_Text)HUDManager.Instance.globalNotificationText).text = displayText;
			HUDManager.Instance.UIAudio.PlayOneShot(HUDManager.Instance.globalNotificationSFX);
		}

		public static void DisplayTip(string headerText, string bodyText, bool isWarning = false)
		{
			((TMP_Text)HUDManager.Instance.tipsPanelHeader).text = headerText;
			((TMP_Text)HUDManager.Instance.tipsPanelBody).text = bodyText;
			if (isWarning)
			{
				HUDManager.Instance.tipsPanelAnimator.SetTrigger("TriggerWarning");
				RoundManager.PlayRandomClip(HUDManager.Instance.UIAudio, HUDManager.Instance.warningSFX, false, 1f, 0, 1000);
			}
			else
			{
				HUDManager.Instance.tipsPanelAnimator.SetTrigger("TriggerHint");
				RoundManager.PlayRandomClip(HUDManager.Instance.UIAudio, HUDManager.Instance.tipsSFX, false, 1f, 0, 1000);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.github.zehsteam.DontTouchMyClogs";

		public const string PLUGIN_NAME = "DontTouchMyClogs";

		public const string PLUGIN_VERSION = "1.0.2";
	}
}
namespace com.github.zehsteam.DontTouchMyClogs.MonoBehaviours
{
	public class Clogs : NoisemakerProp
	{
		[Header("Clogs")]
		[Space(3f)]
		public AudioSource musicAudio = null;

		public AudioSource musicAudioFar = null;

		[HideInInspector]
		public NetworkVariable<bool> isMusicMode = new NetworkVariable<bool>(false, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		public bool isHeldByLocalPlayer => (Object)(object)((GrabbableObject)this).playerHeldBy == (Object)(object)Utils.GetLocalPlayerScript();

		public bool isPlayingVideo => (Object)(object)VideoPlayerBehaviour.Instance != (Object)null && VideoPlayerBehaviour.Instance.isPlaying;

		public bool isPlayingMusic => musicAudio.isPlaying;

		public override void OnNetworkSpawn()
		{
			NetworkVariable<bool> obj = isMusicMode;
			obj.OnValueChanged = (OnValueChangedDelegate<bool>)(object)Delegate.Combine((Delegate?)(object)obj.OnValueChanged, (Delegate?)(object)new OnValueChangedDelegate<bool>(OnIsMusicModeChanged));
		}

		public override void OnNetworkDespawn()
		{
			NetworkVariable<bool> obj = isMusicMode;
			obj.OnValueChanged = (OnValueChangedDelegate<bool>)(object)Delegate.Remove((Delegate?)(object)obj.OnValueChanged, (Delegate?)(object)new OnValueChangedDelegate<bool>(OnIsMusicModeChanged));
		}

		public override void Start()
		{
			((NoisemakerProp)this).Start();
			float volume = Mathf.Clamp(Plugin.ConfigManager.MusicVolume, 0f, 1f);
			if (!Plugin.ConfigManager.EnableMusic)
			{
				musicAudio.mute = true;
				musicAudioFar.mute = true;
			}
			musicAudio.volume = volume;
			musicAudioFar.volume = volume;
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			if (isHeldByLocalPlayer)
			{
				SetIsMusicMode(!isMusicMode.Value);
			}
		}

		public override void DiscardItem()
		{
			if ((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null)
			{
				((GrabbableObject)this).playerHeldBy.equippedUsableItemQE = false;
			}
			((GrabbableObject)this).isBeingUsed = false;
			((GrabbableObject)this).DiscardItem();
		}

		public override void EquipItem()
		{
			((GrabbableObject)this).EquipItem();
			((GrabbableObject)this).playerHeldBy.equippedUsableItemQE = true;
			if (isHeldByLocalPlayer)
			{
				Plugin.Instance.SpawnVideoPlayer();
			}
		}

		public override void ItemInteractLeftRight(bool right)
		{
			((GrabbableObject)this).ItemInteractLeftRight(right);
			if (isHeldByLocalPlayer)
			{
				if (right)
				{
					ItemInteractRight();
				}
				else
				{
					ItemInteractLeft();
				}
			}
		}

		private void ItemInteractLeft()
		{
			if ((Object)(object)VideoPlayerBehaviour.Instance == (Object)null)
			{
				Plugin.logger.LogError((object)"Error: Failed to reset video. VideoPlayerBehaviour Instance does not exist.");
			}
			else if (isMusicMode.Value)
			{
				ResetMusic();
			}
			else
			{
				VideoPlayerBehaviour.Instance.ResetVideo();
			}
		}

		private void ItemInteractRight()
		{
			if ((Object)(object)VideoPlayerBehaviour.Instance == (Object)null)
			{
				Plugin.logger.LogError((object)"Error: Failed to play video. VideoPlayerBehaviour Instance does not exist.");
			}
			else if (isMusicMode.Value)
			{
				bool flag = !isPlayingMusic;
				if (Plugin.ConfigManager.EnableMusic)
				{
					SetIsPlayingMusic(flag);
				}
				else if (!flag)
				{
					SetIsPlayingMusic(flag);
				}
				else
				{
					Utils.DisplayTip("DontTouchMyClogs", "STREAMER WARNING! Music is DMCA.\n\nWooden Clogs - Music is disabled in the config settings.", isWarning: true);
				}
			}
			else
			{
				VideoPlayerBehaviour.Instance.ToggleVideoPlay();
				SetControlTips();
			}
		}

		public override void SetControlTipsForItem()
		{
			SetControlTips();
		}

		private void SetControlTips()
		{
			if (isHeldByLocalPlayer)
			{
				if (isMusicMode.Value)
				{
					SetMusicControlTips();
				}
				else
				{
					SetKaraokeControlTips();
				}
			}
		}

		private void SetKaraokeControlTips()
		{
			string[] toolTips = ((GrabbableObject)this).itemProperties.toolTips;
			if (toolTips.Length <= 2)
			{
				Plugin.logger.LogError((object)"Wooden Clogs control tips array length is too short to set tips!");
				return;
			}
			if (isPlayingVideo)
			{
				toolTips[1] = "Pause Karaoke : [E]";
			}
			else
			{
				toolTips[1] = "Play Karaoke : [E]";
			}
			toolTips[2] = "Reset Karaoke : [Q]";
			HUDManager.Instance.ChangeControlTipMultiple(toolTips, isHeldByLocalPlayer, ((GrabbableObject)this).itemProperties);
		}

		private void SetMusicControlTips()
		{
			string[] toolTips = ((GrabbableObject)this).itemProperties.toolTips;
			if (toolTips.Length <= 2)
			{
				Plugin.logger.LogError((object)"Wooden Clogs control tips array length is too short to set tips!");
				return;
			}
			if (isPlayingMusic)
			{
				toolTips[1] = "Pause Music : [E]";
			}
			else
			{
				toolTips[1] = "Play Music : [E]";
			}
			toolTips[2] = "Reset Music : [Q]";
			HUDManager.Instance.ChangeControlTipMultiple(toolTips, isHeldByLocalPlayer, ((GrabbableObject)this).itemProperties);
		}

		private void SetIsMusicMode(bool enabled)
		{
			if (enabled)
			{
				VideoPlayerBehaviour.Instance.PauseVideo();
			}
			if (Plugin.IsHostOrServer)
			{
				isMusicMode.Value = enabled;
			}
			else
			{
				SetIsMusicModeServerRpc(enabled);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void SetIsMusicModeServerRpc(bool enabled)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1438064405u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref enabled, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1438064405u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					isMusicMode.Value = enabled;
				}
			}
		}

		private void OnIsMusicModeChanged(bool previous, bool current)
		{
			if (Plugin.IsHostOrServer && !current && isPlayingMusic)
			{
				SetIsPlayingMusic(isPlaying: false);
			}
			SetControlTips();
		}

		private void SetIsPlayingMusic(bool isPlaying)
		{
			if (Plugin.IsHostOrServer)
			{
				SetIsPlayingMusicClientRpc(isPlaying);
			}
			else
			{
				SetIsPlayingMusicServerRpc(isPlaying);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void SetIsPlayingMusicServerRpc(bool isPlaying)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3353686090u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isPlaying, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3353686090u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					SetIsPlayingMusicClientRpc(isPlaying);
				}
			}
		}

		[ClientRpc]
		private void SetIsPlayingMusicClientRpc(bool isPlaying)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3874246350u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isPlaying, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3874246350u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (isPlaying)
				{
					musicAudio.Play();
					musicAudioFar.Play();
				}
				else
				{
					musicAudio.Pause();
					musicAudioFar.Pause();
				}
				SetControlTips();
			}
		}

		private void ResetMusic()
		{
			if (Plugin.IsHostOrServer)
			{
				ResetMusicClientRpc();
			}
			else
			{
				ResetMusicServerRpc();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void ResetMusicServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3729213853u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3729213853u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ResetMusicClientRpc();
				}
			}
		}

		[ClientRpc]
		private void ResetMusicClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3375189455u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3375189455u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					musicAudio.time = 0f;
					musicAudioFar.time = 0f;
				}
			}
		}

		protected override void __initializeVariables()
		{
			if (isMusicMode == null)
			{
				throw new Exception("Clogs.isMusicMode cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)isMusicMode).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)isMusicMode, "isMusicMode");
			((NetworkBehaviour)this).NetworkVariableFields.Add((NetworkVariableBase)(object)isMusicMode);
			((NoisemakerProp)this).__initializeVariables();
		}

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_Clogs()
		{
			//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
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(1438064405u, new RpcReceiveHandler(__rpc_handler_1438064405));
			NetworkManager.__rpc_func_table.Add(3353686090u, new RpcReceiveHandler(__rpc_handler_3353686090));
			NetworkManager.__rpc_func_table.Add(3874246350u, new RpcReceiveHandler(__rpc_handler_3874246350));
			NetworkManager.__rpc_func_table.Add(3729213853u, new RpcReceiveHandler(__rpc_handler_3729213853));
			NetworkManager.__rpc_func_table.Add(3375189455u, new RpcReceiveHandler(__rpc_handler_3375189455));
		}

		private static void __rpc_handler_1438064405(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_0044: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool isMusicModeServerRpc = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isMusicModeServerRpc, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Clogs)(object)target).SetIsMusicModeServerRpc(isMusicModeServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3353686090(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_0044: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool isPlayingMusicServerRpc = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isPlayingMusicServerRpc, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((Clogs)(object)target).SetIsPlayingMusicServerRpc(isPlayingMusicServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3874246350(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_0044: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool isPlayingMusicClientRpc = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isPlayingMusicClientRpc, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((Clogs)(object)target).SetIsPlayingMusicClientRpc(isPlayingMusicClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3729213853(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;
				((Clogs)(object)target).ResetMusicServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3375189455(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)2;
				((Clogs)(object)target).ResetMusicClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "Clogs";
		}
	}
	public class VideoPlayerBehaviour : MonoBehaviour
	{
		public static VideoPlayerBehaviour Instance;

		public GameObject containerObject;

		public VideoPlayer videoPlayer;

		public bool isPlaying => videoPlayer.isPlaying;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
		}

		private void Start()
		{
			PauseVideo();
			ResetVideo();
			float num = Mathf.Clamp(Plugin.ConfigManager.VideoVolume, 0f, 1f);
			videoPlayer.SetDirectAudioVolume((ushort)0, num);
		}

		private void OnEnable()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			videoPlayer.loopPointReached += new EventHandler(OnVideoPlayerFinished);
		}

		private void OnDisable()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			videoPlayer.loopPointReached -= new EventHandler(OnVideoPlayerFinished);
		}

		private void OnVideoPlayerFinished(VideoPlayer source)
		{
			containerObject.SetActive(false);
			ResetVideo();
		}

		public void PlayVideo()
		{
			containerObject.SetActive(true);
			videoPlayer.Play();
		}

		public void PauseVideo()
		{
			containerObject.SetActive(false);
			videoPlayer.Pause();
		}

		public void ToggleVideoPlay()
		{
			if (isPlaying)
			{
				PauseVideo();
			}
			else
			{
				PlayVideo();
			}
		}

		public void ResetVideo()
		{
			videoPlayer.time = 0.75;
		}
	}
}
namespace com.github.zehsteam.DontTouchMyClogs.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}

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 BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GokuBracken.Scripts;
using Hallucinoceps;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using com.github.zehsteam.TakeyGoku;
using com.github.zehsteam.TakeyGokuBracken.Compatibility;
using com.github.zehsteam.TakeyGokuBracken.MonoBehaviours;
using com.github.zehsteam.TakeyGokuBracken.NetcodePatcher;
using com.github.zehsteam.TakeyGokuBracken.Patches;

[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("com.github.zehsteam.TakeyGokuBracken")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Adds an easter egg when you have the GokuBracken mod installed.")]
[assembly: AssemblyFileVersion("1.1.2.0")]
[assembly: AssemblyInformationalVersion("1.1.2+6201a226b55ab41cf938f38b45de3b9031d68445")]
[assembly: AssemblyProduct("TakeyGokuBracken")]
[assembly: AssemblyTitle("com.github.zehsteam.TakeyGokuBracken")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.2.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace com.github.zehsteam.TakeyGoku
{
	internal class ConfigManager
	{
		private ConfigEntry<int> SpawnChanceCfg;

		internal int SpawnChance
		{
			get
			{
				return SpawnChanceCfg.Value;
			}
			set
			{
				SpawnChanceCfg.Value = value;
			}
		}

		public ConfigManager()
		{
			BindConfigs();
			ClearUnusedEntries();
		}

		private void BindConfigs()
		{
			//IL_0018: 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_003b: Expected O, but got Unknown
			//IL_003b: Expected O, but got Unknown
			ConfigFile config = ((BaseUnityPlugin)Plugin.Instance).Config;
			SpawnChanceCfg = config.Bind<int>(new ConfigDefinition("General Settings", "SpawnChance"), 25, new ConfigDescription("The percent chance a Goku Bracken turns into a Takey Goku Bracken.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
		}

		private void ClearUnusedEntries()
		{
			ConfigFile config = ((BaseUnityPlugin)Plugin.Instance).Config;
			PropertyInfo property = ((object)config).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
			Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)property.GetValue(config, null);
			dictionary.Clear();
			config.Save();
		}
	}
	internal class Content
	{
		public static GameObject networkHandlerPrefab;

		public static GameObject takeyGokuBrackenControllerPrefab;

		public static AudioClip killSFX;

		public static AudioClip kill2SFX;

		public static AudioClip creepyLaughSFX;

		public static AudioClip iLickyYourTummySFX;

		public static void Load()
		{
			LoadAssetsFromAssetBundle();
		}

		private static void LoadAssetsFromAssetBundle()
		{
			try
			{
				string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location);
				string text = Path.Combine(directoryName, "takeygokubracken_assets");
				AssetBundle val = AssetBundle.LoadFromFile(text);
				networkHandlerPrefab = val.LoadAsset<GameObject>("NetworkHandler");
				networkHandlerPrefab.AddComponent<PluginNetworkBehaviour>();
				takeyGokuBrackenControllerPrefab = val.LoadAsset<GameObject>("TakeyGokuBrackenController");
				killSFX = val.LoadAsset<AudioClip>("KillSFX");
				kill2SFX = val.LoadAsset<AudioClip>("Kill2SFX");
				creepyLaughSFX = val.LoadAsset<AudioClip>("CreepyLaughSFX");
				iLickyYourTummySFX = val.LoadAsset<AudioClip>("ILickyYourTummySFX");
				Plugin.logger.LogInfo((object)"Successfully loaded assets from AssetBundle!");
			}
			catch (Exception arg)
			{
				Plugin.logger.LogError((object)$"Error: failed to load assets from AssetBundle.\n\n{arg}");
			}
		}
	}
	[BepInPlugin("com.github.zehsteam.TakeyGokuBracken", "TakeyGokuBracken", "1.1.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal class Plugin : BaseUnityPlugin
	{
		private readonly Harmony harmony = new Harmony("com.github.zehsteam.TakeyGokuBracken");

		internal static Plugin Instance;

		internal static ManualLogSource logger;

		internal static ConfigManager ConfigManager;

		public static bool IsHostOrServer => NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			logger = Logger.CreateLogSource("com.github.zehsteam.TakeyGokuBracken");
			logger.LogInfo((object)"TakeyGokuBracken has awoken!");
			harmony.PatchAll(typeof(GameNetworkManagerPatch));
			harmony.PatchAll(typeof(StartOfRoundPatch));
			harmony.PatchAll(typeof(FlowermanAIPatch));
			ConfigManager = new ConfigManager();
			Content.Load();
			GokuBrackenCompat.Initialize();
			HallucinocepsCompat.Initialize();
			FlowermanAIPatch.Reset();
			NetcodePatcherAwake();
		}

		private void NetcodePatcherAwake()
		{
			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 void OnLocalDisconnect()
		{
			FlowermanAIPatch.Reset();
		}

		public void OnShipHasLeft()
		{
			FlowermanAIPatch.DespawnAllTakeyGokuControllers();
			FlowermanAIPatch.Reset();
		}

		public bool SetTakeyGokuBrackenOnServer(FlowermanAI flowermanAI)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHostOrServer)
			{
				return false;
			}
			if ((Object)(object)flowermanAI == (Object)null)
			{
				logger.LogError((object)"Error: Failed to set Takey Goku Bracken on server. FlowermanAI is null.");
				return false;
			}
			NetworkObject component = ((Component)flowermanAI).GetComponent<NetworkObject>();
			if (!Utils.IsGokuBracken(flowermanAI))
			{
				logger.LogError((object)$"Error: Failed to set Takey Goku Bracken on server. Enemy is not a Goku Bracken. (NetworkObject: {component.NetworkObjectId})");
				return false;
			}
			if (Utils.IsTakeyGokuBracken(flowermanAI))
			{
				logger.LogWarning((object)$"Warning: Failed to set Takey Goku Bracken on server. Enemy is already a Takey Goku Bracken. (NetworkObject: {component.NetworkObjectId})");
				return false;
			}
			NetworkObject controllerNetworkObject = SpawnTakeyGokuControllerOnServer(((Component)component).transform);
			FlowermanAIPatch.AddTakeyGokuController(controllerNetworkObject);
			PluginNetworkBehaviour.Instance.SetTakeyGokuClientRpc(NetworkObjectReference.op_Implicit(component));
			SetTakeyGokuBrackenOnLocalClient(component);
			return true;
		}

		private NetworkObject SpawnTakeyGokuControllerOnServer(Transform parentTransform)
		{
			//IL_0016: 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)
			if (!IsHostOrServer)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(Content.takeyGokuBrackenControllerPrefab, Vector3.zero, Quaternion.identity, parentTransform);
			NetworkObject component = val.GetComponent<NetworkObject>();
			component.Spawn(true);
			val.transform.SetParent(parentTransform);
			return component;
		}

		public void SetTakeyGokuBrackenOnLocalClient(NetworkObject enemyNetworkObject)
		{
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			if (!GokuBrackenCompat.hasMod)
			{
				return;
			}
			FlowermanAI val = default(FlowermanAI);
			if ((Object)(object)enemyNetworkObject == (Object)null)
			{
				logger.LogError((object)"Error: Failed to set Takey Goku Bracken on local client. Enemy NetworkObject is null.");
			}
			else if (((Component)enemyNetworkObject).TryGetComponent<FlowermanAI>(ref val))
			{
				if (!Utils.IsGokuBracken(val))
				{
					logger.LogError((object)$"Error: Failed to set Takey Goku Bracken on local client. Enemy \"{((Object)((Component)enemyNetworkObject).gameObject).name}\" is not a Goku Bracken. (NetworkObject: {enemyNetworkObject.NetworkObjectId})");
					return;
				}
				if (!FlowermanAIPatch.takeyGokuBrackens.Contains(val))
				{
					try
					{
						Transform val2 = ((Component)enemyNetworkObject).transform.Find("TakeyGokuBrackenController(Clone)");
						val2.localPosition = Vector3.zero;
						val2.localRotation = Quaternion.identity;
						FlowermanAIPatch.AddTakeyGokuBrackenToList(val);
						return;
					}
					catch (Exception arg)
					{
						logger.LogError((object)$"Error: Failed to set Takey Goku Bracken on local client. (NetworkObject: {enemyNetworkObject.NetworkObjectId})\n\n{arg}");
						return;
					}
				}
				logger.LogWarning((object)$"Warning: Failed to set Takey Goku Bracken on local client. Enemy is already a Takey Goku Bracken. (NetworkObject: {enemyNetworkObject.NetworkObjectId})");
			}
			else
			{
				logger.LogError((object)$"Error: Failed to set Takey Goku Bracken on local client. Could not find FlowermanAI. (NetworkObject: {enemyNetworkObject.NetworkObjectId})");
			}
		}
	}
	public class Utils
	{
		public static bool RandomPercent(int percent)
		{
			if (percent <= 0)
			{
				return false;
			}
			if (percent >= 100)
			{
				return true;
			}
			return Random.value <= (float)percent * 0.01f;
		}

		public static bool IsGokuBracken(FlowermanAI flowermanAI)
		{
			return (Object)(object)((Component)flowermanAI).GetComponentInChildren<GokuController>() != (Object)null;
		}

		public static bool IsTakeyGokuBracken(FlowermanAI flowermanAI)
		{
			return (Object)(object)((Component)flowermanAI).GetComponentInChildren<TakeyGokuBrackenBehaviour>() != (Object)null;
		}

		public static bool IsTakeyGokuBracken(FlowermanAI flowermanAI, out TakeyGokuBrackenBehaviour behaviour)
		{
			behaviour = ((Component)flowermanAI).GetComponentInChildren<TakeyGokuBrackenBehaviour>();
			return (Object)(object)behaviour != (Object)null;
		}
	}
}
namespace com.github.zehsteam.TakeyGokuBracken
{
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.github.zehsteam.TakeyGokuBracken";

		public const string PLUGIN_NAME = "TakeyGokuBracken";

		public const string PLUGIN_VERSION = "1.1.2";
	}
}
namespace com.github.zehsteam.TakeyGokuBracken.Patches
{
	[HarmonyPatch(typeof(FlowermanAI))]
	internal class FlowermanAIPatch
	{
		public static List<FlowermanAI> takeyGokuBrackens { get; private set; }

		public static List<NetworkObject> takeyGokuControllers { get; private set; }

		public static void Reset()
		{
			takeyGokuBrackens = new List<FlowermanAI>();
			takeyGokuControllers = new List<NetworkObject>();
		}

		public static void AddTakeyGokuBrackenToList(FlowermanAI flowermanAI)
		{
			if (!takeyGokuBrackens.Contains(flowermanAI))
			{
				takeyGokuBrackens.Add(flowermanAI);
			}
		}

		public static void AddTakeyGokuController(NetworkObject controllerNetworkObject)
		{
			takeyGokuControllers.Add(controllerNetworkObject);
		}

		public static void DespawnAllTakeyGokuControllers()
		{
			if (!Plugin.IsHostOrServer)
			{
				return;
			}
			foreach (NetworkObject takeyGokuController in takeyGokuControllers)
			{
				takeyGokuController.Despawn(true);
			}
			takeyGokuControllers.Clear();
			Plugin.logger.LogInfo((object)"Finished despawning all Takey Goku Controllers.");
		}

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void StartPatch(ref FlowermanAI __instance)
		{
			if (Plugin.IsHostOrServer)
			{
				((MonoBehaviour)StartOfRound.Instance).StartCoroutine(LateStartCO(__instance));
			}
		}

		private static IEnumerator LateStartCO(FlowermanAI flowermanAI)
		{
			yield return (object)new WaitForSeconds(0.5f);
			LateStart(flowermanAI);
		}

		private static void LateStart(FlowermanAI flowermanAI)
		{
			if (Utils.RandomPercent(Plugin.ConfigManager.SpawnChance))
			{
				Plugin.Instance.SetTakeyGokuBrackenOnServer(flowermanAI);
			}
		}

		[HarmonyPatch("KillPlayerAnimationServerRpc")]
		[HarmonyPrefix]
		private static void KillPlayerAnimationServerRpcPatch(ref FlowermanAI __instance)
		{
			if (Utils.IsTakeyGokuBracken(__instance, out var behaviour))
			{
				behaviour.SetRandomCrackNeckSFXOnServer();
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager))]
	internal class GameNetworkManagerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void StartPatch()
		{
			AddNetworkPrefabs();
		}

		private static void AddNetworkPrefabs()
		{
			AddNetworkPrefab(Content.networkHandlerPrefab);
			AddNetworkPrefab(Content.takeyGokuBrackenControllerPrefab);
		}

		private static void AddNetworkPrefab(GameObject prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				Plugin.logger.LogError((object)"Error: Failed to register network prefab. Prefab is null.");
				return;
			}
			NetworkManager.Singleton.AddNetworkPrefab(prefab);
			Plugin.logger.LogInfo((object)("Registered \"" + ((Object)prefab).name + "\" network prefab."));
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePatch()
		{
			SpawnNetworkHandler();
		}

		private static void SpawnNetworkHandler()
		{
			//IL_0014: 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)
			if (Plugin.IsHostOrServer)
			{
				GameObject val = Object.Instantiate<GameObject>(Content.networkHandlerPrefab, Vector3.zero, Quaternion.identity);
				val.GetComponent<NetworkObject>().Spawn(false);
			}
		}

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		[HarmonyPriority(300)]
		private static void StartPatch()
		{
			try
			{
				HallucinocepsCompat.AddHallucinationSounds();
			}
			catch (Exception arg)
			{
				Plugin.logger.LogError((object)$"Error: Failed to add hallucination sounds to the Hallucinoceps mod.\n\n{arg}");
			}
		}

		[HarmonyPatch("ShipHasLeft")]
		[HarmonyPostfix]
		private static void ShipHasLeftPatch()
		{
			Plugin.Instance.OnShipHasLeft();
		}

		[HarmonyPatch("OnLocalDisconnect")]
		[HarmonyPrefix]
		private static void OnLocalDisconnectPatch()
		{
			Plugin.Instance.OnLocalDisconnect();
		}
	}
}
namespace com.github.zehsteam.TakeyGokuBracken.MonoBehaviours
{
	internal class PluginNetworkBehaviour : NetworkBehaviour
	{
		public static PluginNetworkBehaviour Instance;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
		}

		[ClientRpc]
		public void SetTakeyGokuClientRpc(NetworkObjectReference enemyReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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)
			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(3517081936u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref enemyReference, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3517081936u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !((NetworkBehaviour)this).IsHost && !((NetworkBehaviour)this).IsServer)
			{
				NetworkObject takeyGokuBrackenOnLocalClient = default(NetworkObject);
				if (((NetworkObjectReference)(ref enemyReference)).TryGet(ref takeyGokuBrackenOnLocalClient, (NetworkManager)null))
				{
					Plugin.Instance.SetTakeyGokuBrackenOnLocalClient(takeyGokuBrackenOnLocalClient);
				}
				else
				{
					Plugin.Instance.SetTakeyGokuBrackenOnLocalClient(null);
				}
			}
		}

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

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_PluginNetworkBehaviour()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(3517081936u, new RpcReceiveHandler(__rpc_handler_3517081936));
		}

		private static void __rpc_handler_3517081936(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_0044: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference takeyGokuClientRpc = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref takeyGokuClientRpc, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((PluginNetworkBehaviour)(object)target).SetTakeyGokuClientRpc(takeyGokuClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "PluginNetworkBehaviour";
		}
	}
	public class TakeyGokuBrackenBehaviour : NetworkBehaviour
	{
		public Material clothesMaterial = null;

		public Material headMaterial = null;

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

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

		private FlowermanAI _flowermanAI;

		private ScanNodeProperties _scanNodeProperties;

		private PlayAudioAnimationEvent _playAudioAnimationEvent;

		private float timer = 0f;

		public FlowermanAI flowermanAI
		{
			get
			{
				if ((Object)(object)_flowermanAI == (Object)null)
				{
					_flowermanAI = ((Component)((Component)this).transform.parent).GetComponent<FlowermanAI>();
				}
				return _flowermanAI;
			}
		}

		public ScanNodeProperties scanNodeProperties
		{
			get
			{
				if ((Object)(object)_scanNodeProperties == (Object)null)
				{
					_scanNodeProperties = ((Component)flowermanAI).GetComponentInChildren<ScanNodeProperties>();
				}
				return _scanNodeProperties;
			}
		}

		public PlayAudioAnimationEvent playAudioAnimationEvent
		{
			get
			{
				if ((Object)(object)_playAudioAnimationEvent == (Object)null)
				{
					_playAudioAnimationEvent = ((Component)flowermanAI).GetComponentInChildren<PlayAudioAnimationEvent>();
				}
				return _playAudioAnimationEvent;
			}
		}

		private void Start()
		{
			if (GokuBrackenCompat.hasMod)
			{
				SetMaterials();
				SetScanNodeProperties("Takey Goku");
				if (Plugin.IsHostOrServer)
				{
					SetSFXOnServer();
				}
			}
		}

		private void Update()
		{
			if (GokuBrackenCompat.hasMod && Plugin.IsHostOrServer)
			{
				if (timer >= 20f)
				{
					timer = 0f;
					SetRandomFoundSFXOnServer();
				}
				timer += Time.deltaTime;
			}
		}

		private void SetMaterials()
		{
			SkinnedMeshRenderer componentInChildren = ((Component)((Component)flowermanAI).transform.GetChild(4)).GetComponentInChildren<SkinnedMeshRenderer>();
			SetSkinnedMeshRendererMaterials(componentInChildren, clothesMaterial, headMaterial);
			SkinnedMeshRenderer componentInChildren2 = ((Component)((Component)flowermanAI).transform.GetChild(5)).GetComponentInChildren<SkinnedMeshRenderer>();
			SetSkinnedMeshRendererMaterials(componentInChildren2, clothesMaterial, headMaterial);
		}

		private static void SetSkinnedMeshRendererMaterials(SkinnedMeshRenderer skinnedMeshRenderer, Material material1, Material material2)
		{
			Material[] materials = ((Renderer)skinnedMeshRenderer).materials;
			materials[0] = material1;
			materials[1] = material2;
			((Renderer)skinnedMeshRenderer).materials = materials;
		}

		private void SetSFXOnServer()
		{
			SetRandomCrackNeckSFXOnServer();
			SetRandomFoundSFXOnServer();
		}

		public void SetRandomCrackNeckSFXOnServer()
		{
			if (Plugin.IsHostOrServer)
			{
				int crackNeckSFXClientRpc = Random.Range(0, takeyCrackNeckSFX.Length);
				SetCrackNeckSFXClientRpc(crackNeckSFXClientRpc);
			}
		}

		[ClientRpc]
		private void SetCrackNeckSFXClientRpc(int index)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2929643050u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, index);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2929643050u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && GokuBrackenCompat.hasMod)
				{
					AudioClip val3 = takeyCrackNeckSFX[index];
					flowermanAI.crackNeckSFX = val3;
					flowermanAI.crackNeckAudio.clip = val3;
				}
			}
		}

		public void SetRandomFoundSFXOnServer()
		{
			if (Plugin.IsHostOrServer)
			{
				int foundSFXClientRpc = Random.Range(0, takeyFoundSFX.Length);
				SetFoundSFXClientRpc(foundSFXClientRpc);
			}
		}

		[ClientRpc]
		private void SetFoundSFXClientRpc(int index)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3425590996u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, index);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3425590996u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && GokuBrackenCompat.hasMod)
				{
					playAudioAnimationEvent.audioClip = takeyFoundSFX[index];
				}
			}
		}

		private void SetScanNodeProperties(string headerText)
		{
			scanNodeProperties.headerText = headerText;
		}

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

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

		private static void __rpc_handler_2929643050(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 crackNeckSFXClientRpc = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref crackNeckSFXClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((TakeyGokuBrackenBehaviour)(object)target).SetCrackNeckSFXClientRpc(crackNeckSFXClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3425590996(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 foundSFXClientRpc = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref foundSFXClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((TakeyGokuBrackenBehaviour)(object)target).SetFoundSFXClientRpc(foundSFXClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "TakeyGokuBrackenBehaviour";
		}
	}
}
namespace com.github.zehsteam.TakeyGokuBracken.Compatibility
{
	internal class GokuBrackenCompat
	{
		public const string ModGUID = "Vulf.GokuBracken";

		public static bool hasMod;

		public static void Initialize()
		{
			hasMod = Chainloader.PluginInfos.ContainsKey("Vulf.GokuBracken");
		}
	}
	internal class HallucinocepsCompat
	{
		public const string ModGUID = "PloufJPEG.Hallucinoceps";

		public static bool hasMod;

		public static void Initialize()
		{
			hasMod = Chainloader.PluginInfos.ContainsKey("PloufJPEG.Hallucinoceps");
		}

		public static void AddHallucinationSounds()
		{
			if (!hasMod)
			{
				return;
			}
			try
			{
				List<AudioClip> list = CompanyCreaturesNetworker.instance.hallucinationSounds.ToList();
				list.Add(Content.killSFX);
				list.Add(Content.kill2SFX);
				list.Add(Content.creepyLaughSFX);
				list.Add(Content.iLickyYourTummySFX);
				CompanyCreaturesNetworker.instance.hallucinationSounds = list.ToArray();
				Plugin.logger.LogInfo((object)"Added hallucination sounds to the Hallucinoceps mod.");
			}
			catch (Exception arg)
			{
				Plugin.logger.LogInfo((object)$"Error: Failed to add hallucination sounds to the Hallucinoceps mod.\n\n{arg}");
			}
		}
	}
}
namespace com.github.zehsteam.TakeyGokuBracken.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}