Decompiled source of Vacuity Moon v1.0.6

Get the Thunderstore App

Easily install and manage your mods with the Thunderstore App!
Decompiled source of Vacuity Moon v1.0.6

bauyrsaq.Ce.Vacuity.dll

Decompiled 6 months ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
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 HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using bauyrsaq.Ce.Vacuity.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: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: AssemblyCompany("bauyrsaq.Ce.Vacuity")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("VacuityXode")]
[assembly: AssemblyTitle("bauyrsaq.Ce.Vacuity")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.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;
		}
	}
}
internal class Config
{
	public struct Category
	{
		public static Category MAIN => new Category("- Main Config Settings -");

		public string Value { get; private set; }

		public Category(string value)
		{
			Value = value;
		}
	}

	private readonly ConfigFile configFile;

	public readonly ConfigEntry<int> clearPlayerPrefs;

	private ConfigEntry<T> NewEntry<T>(string key, T defaultVal, string desc)
	{
		return NewEntry(Category.MAIN, key, defaultVal, desc);
	}

	private ConfigEntry<T> NewEntry<T>(Category category, string key, T defaultVal, string desc)
	{
		return configFile.Bind<T>(category.Value, key, defaultVal, desc);
	}

	public Config(ConfigFile cfg)
	{
		configFile = cfg;
		cfg.SaveOnConfigSet = false;
		clearPlayerPrefs = NewEntry(Category.MAIN, "setClearPlayerPrefs", 0, "Clear Moon Save");
		ClearOrphanedEntries(cfg);
		cfg.Save();
		cfg.SaveOnConfigSet = true;
	}

	private static void ClearOrphanedEntries(ConfigFile cfg)
	{
		PropertyInfo propertyInfo = AccessTools.Property(typeof(ConfigFile), "OrphanedEntries");
		Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)propertyInfo.GetValue(cfg);
		dictionary.Clear();
	}
}
namespace BusXode.Patches
{
	public class VHangarShipReplacer : MonoBehaviour
	{
		public AnimationClip customClip;

		private Animator hangarShipAnimator;

		private AnimationClip originalClip;

		private RuntimeAnimatorController animatorController;

		private void Start()
		{
			GameObject val = GameObject.Find("HangarShip");
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogError((object)"HangarShip GameObject not found.");
				return;
			}
			hangarShipAnimator = val.GetComponent<Animator>();
			if ((Object)(object)hangarShipAnimator == (Object)null)
			{
				Debug.LogError((object)"Animator component not found on HangarShip.");
				return;
			}
			animatorController = hangarShipAnimator.runtimeAnimatorController;
			AnimationClip[] animationClips = animatorController.animationClips;
			foreach (AnimationClip val2 in animationClips)
			{
				if (((Object)val2).name == "HangarShipLandB")
				{
					originalClip = val2;
					break;
				}
			}
			if ((Object)(object)originalClip == (Object)null)
			{
				Debug.LogError((object)"Animation clip HangarShipLand not found in the Animator.");
			}
			else
			{
				ReplaceAnimationClip(customClip);
			}
		}

		private void ReplaceAnimationClip(AnimationClip newClip)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			if ((Object)(object)newClip != (Object)null && (Object)(object)animatorController != (Object)null && (Object)(object)originalClip != (Object)null)
			{
				AnimatorOverrideController val = new AnimatorOverrideController(animatorController);
				val[originalClip] = newClip;
				hangarShipAnimator.runtimeAnimatorController = (RuntimeAnimatorController)(object)val;
				Debug.Log((object)"Replaced HangarShipLand with the custom animation clip.");
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)hangarShipAnimator != (Object)null && (Object)(object)animatorController != (Object)null && (Object)(object)originalClip != (Object)null)
			{
				hangarShipAnimator.runtimeAnimatorController = animatorController;
				Debug.Log((object)"Reverted to the original HangarShipLand animation clip.");
			}
		}
	}
}
namespace VacuityXode
{
	[BepInPlugin("bauyrsaq.Ce.Vacuity", "VacuityXode", "1.0.0")]
	public class VacuityXode : BaseUnityPlugin
	{
		public static int clearSave = 0;

		public static int fixedCutsceneIndex = 2;

		public static bool fixedCutsceneToggled = false;

		public static bool winterMode = true;

		public static bool fixedSeason = false;

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


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


		internal static Config BoundConfig { get; private set; } = null;


		internal static Harmony? Harmony { get; set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			NetcodePatcher();
			Patch();
			Logger.LogInfo((object)"bauyrsaq.Ce.Vacuity v1.0.0, Vacuity Moon has been loaded. Now loading code...");
			DisplayWelcomeMessage();
			clearSave = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Reset Mod Save Game", 0, "Set value '1' if you want to remove save").Value;
			fixedCutsceneIndex = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Fixed Cutscene Index", 2, "[Requires last option enabled] Set value from 0 (zero is the first cutscene) to 6 (last cutscene)").Value;
			fixedCutsceneToggled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Fixed Cutscene Enabled", false, "Enable/Disable fixed cutscene, with that I mean looped one cutscene everytime you land to this moon.").Value;
			if (clearSave >= 1)
			{
				if (PlayerPrefs.GetInt("clearedSaveVacuity") <= 0)
				{
					ResetPlayerPrefs();
					clearSave = 0;
					PlayerPrefs.SetInt("clearedSaveVacuity", 1);
				}
			}
			else
			{
				PlayerPrefs.SetInt("clearedSaveVacuity", 0);
			}
			fixedSeason = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Fixed season", false, "Enable/Disable fixed season, it means no random winter/desert selection.").Value;
			winterMode = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Fixed Winter", true, "True means always winter, false means always desert (requires fixed season toggled)").Value;
		}

		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("bauyrsaq.Ce.Vacuity");
			}
			Logger.LogDebug((object)"Starting the patching process...");
			Harmony.PatchAll();
			Logger.LogDebug((object)"Patching process completed!");
		}

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

		private static void DisplayWelcomeMessage()
		{
			Logger.LogInfo((object)"Remember there was big ASCII art? ;)");
		}

		public void ResetPlayerPrefs()
		{
			PlayerPrefs.SetInt("Vac_CutsceneIndex", 0);
		}

		private 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 = "bauyrsaq.Ce.Vacuity";

		public const string PLUGIN_NAME = "VacuityXode";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace VacuityXode.Patches
{
	public class VacuityBoombox : NetworkBehaviour
	{
		[Header("Vacuity Boombox Settings")]
		[Space]
		public AudioSource boomboxAudio;

		public AudioClip boomboxUseSound;

		public AudioClip boomboxDisableSound;

		[SerializeField]
		private Animator boomboxUser;

		[SerializeField]
		private Animator boomboxAnimator;

		public bool boomboxEnabled = true;

		private bool alreadyShuttingDown = false;

		private bool calledOnce = false;

		private void Awake()
		{
			VacuityXode.Logger.LogWarning((object)"! Boombox woke up !");
		}

		public void Start()
		{
			VacuityXode.Logger.LogWarning((object)"! Boombox on Start method !");
		}

		public void CallLaterOnceBoombox()
		{
			boomboxAnimator = ((Component)this).GetComponentInChildren<Animator>();
			VacuityXode.Logger.LogWarning((object)"! Have to turn on boombox !");
			EnableBoomboxServerRpc();
			calledOnce = true;
		}

		public void DisableBoombox()
		{
			DisableBoomboxServerRpc();
		}

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

		[ClientRpc]
		public void DisableBoomboxClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1108938150u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1108938150u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ToggleBoombox(enable: false);
				}
			}
		}

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

		[ClientRpc]
		public void EnableBoomboxClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1191075924u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1191075924u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ToggleBoombox(enable: true);
				}
			}
		}

		public void ToggleBoombox(bool enable)
		{
			if (enable)
			{
				VacuityXode.Logger.LogWarning((object)"Enable Boombox");
				boomboxAnimator.SetBool("play", true);
				boomboxAudio.loop = true;
				boomboxAudio.PlayOneShot(boomboxUseSound);
				boomboxAudio.Play();
				boomboxEnabled = true;
			}
			else
			{
				VacuityXode.Logger.LogWarning((object)"Disable Boombox");
				boomboxAnimator.SetBool("play", false);
				boomboxAudio.PlayOneShot(boomboxDisableSound);
				boomboxAudio.Stop();
				EnableBackBoombox();
				boomboxEnabled = false;
			}
		}

		public void EnableBackBoombox()
		{
			((MonoBehaviour)this).StartCoroutine(BoomboxAnimWorker());
		}

		private IEnumerator BoomboxAnimWorker()
		{
			alreadyShuttingDown = true;
			boomboxUser.SetBool("vibing", false);
			yield return (object)new WaitForSeconds(4.4f);
			boomboxUser.SetTrigger("useBoombox");
			yield return (object)new WaitForSeconds(1f);
			EnableBoomboxServerRpc();
			yield return (object)new WaitForSeconds(1f);
			boomboxUser.SetBool("vibing", true);
			alreadyShuttingDown = false;
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(122075439u, new RpcReceiveHandler(__rpc_handler_122075439), "DisableBoomboxServerRpc");
			((NetworkBehaviour)this).__registerRpc(1108938150u, new RpcReceiveHandler(__rpc_handler_1108938150), "DisableBoomboxClientRpc");
			((NetworkBehaviour)this).__registerRpc(4140995057u, new RpcReceiveHandler(__rpc_handler_4140995057), "EnableBoomboxServerRpc");
			((NetworkBehaviour)this).__registerRpc(1191075924u, new RpcReceiveHandler(__rpc_handler_1191075924), "EnableBoomboxClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_122075439(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;
				((VacuityBoombox)(object)target).DisableBoomboxServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1108938150(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;
				((VacuityBoombox)(object)target).DisableBoomboxClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4140995057(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;
				((VacuityBoombox)(object)target).EnableBoomboxServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1191075924(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;
				((VacuityBoombox)(object)target).EnableBoomboxClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "VacuityBoombox";
		}
	}
	public class VacuityBunkerDoor : NetworkBehaviour
	{
		[Header("Bunker Door Settings")]
		[Space]
		public Animator bunkerDoorAnimator;

		public Animator propLiftAnimator;

		public AudioSource bunkerDoorAudio;

		public Light doorButtonLight;

		public bool isOpen = false;

		public void OpenDoor()
		{
			OpenDoor_ServerRpc();
		}

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

		[ClientRpc]
		public void OpenDoor_ClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3258166915u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3258166915u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!isOpen)
				{
					bunkerDoorAnimator.SetTrigger("Open");
					((Behaviour)doorButtonLight).enabled = false;
					((MonoBehaviour)this).StartCoroutine(DoorAudioCoroutine());
					isOpen = true;
				}
			}
		}

		private IEnumerator DoorAudioCoroutine()
		{
			yield return (object)new WaitForSeconds(0.3f);
			bunkerDoorAudio.Play();
			yield return (object)new WaitForSeconds(6f);
			propLiftAnimator.SetTrigger("start");
			bunkerDoorAudio.Stop();
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(672259866u, new RpcReceiveHandler(__rpc_handler_672259866), "OpenDoor_ServerRpc");
			((NetworkBehaviour)this).__registerRpc(3258166915u, new RpcReceiveHandler(__rpc_handler_3258166915), "OpenDoor_ClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_672259866(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;
				((VacuityBunkerDoor)(object)target).OpenDoor_ServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3258166915(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;
				((VacuityBunkerDoor)(object)target).OpenDoor_ClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "VacuityBunkerDoor";
		}
	}
	public class VacuityCutsceneManager : NetworkBehaviour
	{
		[Header("Cutscene Settings")]
		[Space]
		public Animator[] doorWorkerAnimators;

		public List<GameObject> cutsceneDayObjects = new List<GameObject>();

		public VacuityBunkerDoor bunkerDoor;

		public bool calledWorker = false;

		private int cutsceneIndex = -1;

		public int lastIndex = 3;

		[HideInInspector]
		public bool fixedIndex = false;

		[HideInInspector]
		public int fixedIndexValue = 0;

		[Space]
		public Animator yellowGuyAnimator;

		public GameObject knifeObject;

		[Header("Season Settings")]
		[Space]
		public Light sunWithShadows;

		public Color desertSunWithShadowsColor;

		public Color winterSunWithShadowsColor;

		public List<VCCactus> cactuses = new List<VCCactus>();

		public List<GameObject> desertObjects = new List<GameObject>();

		public Material desertTerrainMat;

		public List<GameObject> snowyObjects = new List<GameObject>();

		public Material snowyTerrainMat;

		public MeshRenderer vacuityTerrain;

		public Transform shipDecals;

		private Transform ship;

		public Vector3 shipDecalsLocalPosition = new Vector3(55.84f, 10.835f, -29.012f);

		private int SERVER_SEASON = -1;

		public bool isWinter = false;

		private bool updateShipDecals = false;

		private bool gameStarted = false;

		private bool startChecking = true;

		[ServerRpc(RequireOwnership = false)]
		public void SetupSeason_ServerRpc(int winter)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1964511085u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, winter);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1964511085u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SetupSeason_ClientRpc(winter);
				}
			}
		}

		[ClientRpc]
		public void SetupSeason_ClientRpc(int winter)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2959014072u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, winter);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2959014072u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SetupSeason(winter);
				}
			}
		}

		public void SetupSeason(int winter)
		{
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			if (winter == 1)
			{
				foreach (VCCactus cactuse in cactuses)
				{
					cactuse.SetCactusMaterial(winter: true);
				}
				foreach (GameObject desertObject in desertObjects)
				{
					desertObject.SetActive(false);
				}
				foreach (GameObject snowyObject in snowyObjects)
				{
					snowyObject.SetActive(true);
				}
				((Renderer)vacuityTerrain).material = snowyTerrainMat;
				((Component)vacuityTerrain).tag = "Snow";
				((Component)shipDecals).gameObject.SetActive(true);
				updateShipDecals = true;
				sunWithShadows.color = winterSunWithShadowsColor;
				isWinter = true;
				return;
			}
			foreach (VCCactus cactuse2 in cactuses)
			{
				cactuse2.SetCactusMaterial(winter: false);
			}
			foreach (GameObject desertObject2 in desertObjects)
			{
				desertObject2.SetActive(true);
			}
			foreach (GameObject snowyObject2 in snowyObjects)
			{
				snowyObject2.SetActive(false);
			}
			((Renderer)vacuityTerrain).material = desertTerrainMat;
			((Component)vacuityTerrain).tag = "Gravel";
			((Component)shipDecals).gameObject.SetActive(false);
			updateShipDecals = false;
			sunWithShadows.color = desertSunWithShadowsColor;
			isWinter = false;
		}

		public void TriggerYellowGuyCorpse()
		{
			TriggerYellowGuyCorpse_ServerRpc();
		}

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

		[ClientRpc]
		public void TriggerYellowGuyCorpse_ClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2589715123u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2589715123u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					yellowGuyAnimator.SetTrigger("fall");
					knifeObject.SetActive(false);
				}
			}
		}

		private void Start()
		{
			((MonoBehaviour)this).Invoke("SetStartCheck", 3f);
		}

		public void SetStartCheck()
		{
			startChecking = true;
		}

		private void Update()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (updateShipDecals && gameStarted)
			{
				((Component)shipDecals).transform.position = ((Component)ship).transform.position;
				((Component)shipDecals).transform.rotation = ((Component)ship).transform.rotation;
			}
			if (startChecking && !gameStarted && StartOfRound.Instance.fullyLoadedPlayers.Count >= GameNetworkManager.Instance.connectedPlayers)
			{
				ship = GameObject.Find("HangarShip").transform;
				if ((Object)(object)shipDecals == (Object)null)
				{
					shipDecals = GameObject.Find("_ShipDecals_").transform;
				}
				if (((NetworkBehaviour)this).IsOwner)
				{
					CallActivateCutscene_Later();
				}
				gameStarted = true;
			}
		}

		private void OnDestroy()
		{
			shipDecals.parent = null;
			Object.Destroy((Object)(object)((Component)shipDecals).gameObject);
		}

		public void CallActivateCutscene_Later()
		{
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)StartOfRound.Instance != (Object)null)
			{
				if (((NetworkBehaviour)this).IsOwner)
				{
					if (!VacuityXode.fixedSeason)
					{
						SERVER_SEASON = GetRandomIntFromSeed(StartOfRound.Instance.randomMapSeed);
					}
					else if (!VacuityXode.winterMode)
					{
						SERVER_SEASON = 0;
					}
					else
					{
						SERVER_SEASON = 1;
					}
					SetupSeason_ServerRpc(SERVER_SEASON);
					VacuityBoombox vacuityBoombox = Object.FindObjectOfType<VacuityBoombox>();
					if ((Object)(object)vacuityBoombox != (Object)null)
					{
						vacuityBoombox.CallLaterOnceBoombox();
					}
				}
				VacuityXode.Logger.LogInfo((object)("Selected season value: " + SERVER_SEASON));
			}
			else
			{
				VacuityXode.Logger.LogError((object)"StartOfRound.Instance is null. Cannot send season info!!!");
			}
			if (((NetworkBehaviour)this).IsOwner)
			{
				fixedIndexValue = VacuityXode.fixedCutsceneIndex;
				fixedIndex = VacuityXode.fixedCutsceneToggled;
				if (fixedIndex)
				{
					ActivateCutsceneObjectServerRpc(fixedIndexValue);
					return;
				}
				int @int = PlayerPrefs.GetInt("Vac_CutsceneIndex", 0);
				if (@int >= 0 && @int < cutsceneDayObjects.Count)
				{
					ActivateCutsceneObjectServerRpc(@int);
				}
				cutsceneIndex = @int;
				if (lastIndex >= @int + 1)
				{
					PlayerPrefs.SetInt("Vac_CutsceneIndex", @int + 1);
				}
				else
				{
					PlayerPrefs.SetInt("Vac_CutsceneIndex", 0);
				}
			}
			startChecking = false;
		}

		public int GetRandomIntFromSeed(int mapSeed)
		{
			Random random = new Random(mapSeed);
			return random.Next(0, 2);
		}

		private int GetValueBasedOnSeed(int seed)
		{
			return seed % 2;
		}

		[ServerRpc(RequireOwnership = false)]
		private void ActivateCutsceneObjectServerRpc(int index, ServerRpcParams rpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(100129372u, rpcParams, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val, index);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 100129372u, rpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					cutsceneIndex = index;
					ActivateCutsceneObjectClientRpc(cutsceneIndex);
					VacuityXode.Logger.LogWarning((object)"! Activate Cutscene server RPC !");
				}
			}
		}

		[ClientRpc]
		private void ActivateCutsceneObjectClientRpc(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)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(712420259u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, index);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 712420259u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			cutsceneIndex = index;
			VacuityXode.Logger.LogWarning((object)"! Activate Cutscene client RPC !");
			foreach (GameObject cutsceneDayObject in cutsceneDayObjects)
			{
				cutsceneDayObject.SetActive(false);
			}
			if (index >= 0 && index < cutsceneDayObjects.Count)
			{
				cutsceneDayObjects[index].SetActive(true);
				if (index == 3)
				{
					OpenDoorWorker();
				}
			}
		}

		public void OpenDoorWorker()
		{
			OpenDoorWorker_ServerRpc();
		}

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

		[ClientRpc]
		public void OpenDoorWorker_ClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(299160354u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 299160354u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!calledWorker)
			{
				Animator[] array = doorWorkerAnimators;
				foreach (Animator val3 in array)
				{
					val3.SetTrigger("openDoor");
				}
				((MonoBehaviour)this).StartCoroutine(DoorWorkerCallInteractTrigger());
				calledWorker = true;
			}
		}

		private IEnumerator DoorWorkerCallInteractTrigger()
		{
			yield return (object)new WaitForSeconds(3.2f);
			if (cutsceneIndex <= 0 || cutsceneIndex == 2 || cutsceneIndex == 5)
			{
				bunkerDoor.OpenDoor();
			}
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1964511085u, new RpcReceiveHandler(__rpc_handler_1964511085), "SetupSeason_ServerRpc");
			((NetworkBehaviour)this).__registerRpc(2959014072u, new RpcReceiveHandler(__rpc_handler_2959014072), "SetupSeason_ClientRpc");
			((NetworkBehaviour)this).__registerRpc(408892450u, new RpcReceiveHandler(__rpc_handler_408892450), "TriggerYellowGuyCorpse_ServerRpc");
			((NetworkBehaviour)this).__registerRpc(2589715123u, new RpcReceiveHandler(__rpc_handler_2589715123), "TriggerYellowGuyCorpse_ClientRpc");
			((NetworkBehaviour)this).__registerRpc(100129372u, new RpcReceiveHandler(__rpc_handler_100129372), "ActivateCutsceneObjectServerRpc");
			((NetworkBehaviour)this).__registerRpc(712420259u, new RpcReceiveHandler(__rpc_handler_712420259), "ActivateCutsceneObjectClientRpc");
			((NetworkBehaviour)this).__registerRpc(3053071387u, new RpcReceiveHandler(__rpc_handler_3053071387), "OpenDoorWorker_ServerRpc");
			((NetworkBehaviour)this).__registerRpc(299160354u, new RpcReceiveHandler(__rpc_handler_299160354), "OpenDoorWorker_ClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_1964511085(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 winter = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref winter);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((VacuityCutsceneManager)(object)target).SetupSeason_ServerRpc(winter);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2959014072(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 winter = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref winter);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((VacuityCutsceneManager)(object)target).SetupSeason_ClientRpc(winter);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_408892450(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;
				((VacuityCutsceneManager)(object)target).TriggerYellowGuyCorpse_ServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2589715123(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;
				((VacuityCutsceneManager)(object)target).TriggerYellowGuyCorpse_ClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_100129372(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_0040: 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)
			{
				int index = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref index);
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((VacuityCutsceneManager)(object)target).ActivateCutsceneObjectServerRpc(index, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_712420259(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 index = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref index);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((VacuityCutsceneManager)(object)target).ActivateCutsceneObjectClientRpc(index);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3053071387(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;
				((VacuityCutsceneManager)(object)target).OpenDoorWorker_ServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_299160354(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;
				((VacuityCutsceneManager)(object)target).OpenDoorWorker_ClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "VacuityCutsceneManager";
		}
	}
	public class VacuityElevator : NetworkBehaviour
	{
		[Header("Elevator Settings")]
		[Space]
		public Animator elevatorAnimator;

		[HideInInspector]
		public bool elevatorIsOnUpFloor = true;

		[HideInInspector]
		public bool isOnMovement = false;

		[HideInInspector]
		public bool goingUp = false;

		public AudioSource elevatorAudioLoop;

		public void CallLift()
		{
			CallLift_ServerRpc();
		}

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

		[ClientRpc]
		public void CallLift_ClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3577632944u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3577632944u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!isOnMovement)
				{
					((MonoBehaviour)this).StartCoroutine(ElevatorCoroutine(!elevatorIsOnUpFloor));
					elevatorIsOnUpFloor = !elevatorIsOnUpFloor;
				}
			}
		}

		private IEnumerator ElevatorCoroutine(bool moveUp)
		{
			isOnMovement = true;
			yield return (object)new WaitForSeconds(0.5f);
			elevatorAudioLoop.Play();
			goingUp = moveUp;
			if (moveUp)
			{
				elevatorAnimator.SetTrigger("goUp");
				ShakePlayerCamera(shakeHard: true);
			}
			else
			{
				elevatorAnimator.SetTrigger("goDown");
				ShakePlayerCamera(shakeHard: false);
			}
			yield return (object)new WaitForSeconds(13.5f);
			goingUp = false;
			isOnMovement = false;
			elevatorAudioLoop.Stop();
		}

		private void ShakePlayerCamera(bool shakeHard)
		{
			//IL_0010: 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)
			if (Vector3.Distance(((Component)StartOfRound.Instance.audioListener).transform.position, ((Component)elevatorAnimator).gameObject.transform.GetChild(0).position) < 7.75f)
			{
				if (shakeHard)
				{
					HUDManager.Instance.ShakeCamera((ScreenShakeType)1);
				}
				else
				{
					HUDManager.Instance.ShakeCamera((ScreenShakeType)2);
				}
			}
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1849749306u, new RpcReceiveHandler(__rpc_handler_1849749306), "CallLift_ServerRpc");
			((NetworkBehaviour)this).__registerRpc(3577632944u, new RpcReceiveHandler(__rpc_handler_3577632944), "CallLift_ClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_1849749306(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;
				((VacuityElevator)(object)target).CallLift_ServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3577632944(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;
				((VacuityElevator)(object)target).CallLift_ClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "VacuityElevator";
		}
	}
	public class VacuityMines : NetworkBehaviour
	{
		[Header("Landmines Settings")]
		[Space]
		public List<GameObject> landmines;

		public int minActiveLandmines = 8;

		public int maxActiveLandmines = 17;

		public int mapSeed = 12345;

		private void Start()
		{
			((MonoBehaviour)this).Invoke("ActivateRandomLandmines", 3f);
		}

		private void ActivateRandomLandmines()
		{
			mapSeed = StartOfRound.Instance.randomMapSeed;
			Random.InitState(mapSeed);
			int num = Random.Range(minActiveLandmines, maxActiveLandmines + 1);
			ShuffleLandmines();
			for (int i = 0; i < num; i++)
			{
				if (i < landmines.Count)
				{
					landmines[i].SetActive(true);
				}
			}
			for (int j = num; j < landmines.Count; j++)
			{
				landmines[j].SetActive(false);
			}
		}

		private void ShuffleLandmines()
		{
			for (int i = 0; i < landmines.Count; i++)
			{
				int index = Random.Range(0, landmines.Count);
				GameObject value = landmines[i];
				landmines[i] = landmines[index];
				landmines[index] = value;
			}
		}

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

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

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "VacuityMines";
		}
	}
	public class VacuityRadiation : NetworkBehaviour
	{
		[Header("Radiation Setings")]
		[Space]
		public bool showMessage = true;

		public void ShowMessage()
		{
			HUDManager.Instance.DisplayTip("WARNING", "High radiation level!", true, false, "LC_Tip1");
		}

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

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

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "VacuityRadiation";
		}
	}
	public class VacuityRepair : NetworkBehaviour
	{
		[Header("Repairer Settings")]
		[Space]
		public VacuityElevator elevator;

		public Animator repairerAnimator;

		[HideInInspector]
		public bool calledVent = false;

		[HideInInspector]
		public bool calledSit = false;

		public void InteractTrigger_Vent()
		{
			VentServerRpc();
		}

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

		[ClientRpc]
		public void VentClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4127187543u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4127187543u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SetAnimTriggerServerRpc("vent");
					calledVent = true;
				}
			}
		}

		public void InteractTrigger_Sit()
		{
			ResetAnimTrigger("vent");
			VacuityXode.Logger.LogWarning((object)"Calling trigger 'InteractTrigger_Sit'");
			SitServerRpc();
		}

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

		[ClientRpc]
		public void SitClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3589870043u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3589870043u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!calledSit)
				{
					SetAnimTriggerServerRpc("sit");
					calledSit = true;
				}
			}
		}

		public void SetAnimTrigger(string name)
		{
			repairerAnimator.SetTrigger(name);
			VacuityXode.Logger.LogWarning((object)("Calling trigger " + name));
		}

		public void ResetAnimTrigger(string name)
		{
			repairerAnimator.ResetTrigger(name);
			VacuityXode.Logger.LogWarning((object)("Calling trigger " + name));
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetAnimTriggerServerRpc(string name)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			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(655974850u, val, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(name, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 655974850u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				SetAnimTriggerClientRpc(name);
			}
		}

		[ClientRpc]
		public void SetAnimTriggerClientRpc(string name)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2259893442u, val, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(name, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2259893442u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				SetAnimTrigger(name);
			}
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1815470203u, new RpcReceiveHandler(__rpc_handler_1815470203), "VentServerRpc");
			((NetworkBehaviour)this).__registerRpc(4127187543u, new RpcReceiveHandler(__rpc_handler_4127187543), "VentClientRpc");
			((NetworkBehaviour)this).__registerRpc(2353497863u, new RpcReceiveHandler(__rpc_handler_2353497863), "SitServerRpc");
			((NetworkBehaviour)this).__registerRpc(3589870043u, new RpcReceiveHandler(__rpc_handler_3589870043), "SitClientRpc");
			((NetworkBehaviour)this).__registerRpc(655974850u, new RpcReceiveHandler(__rpc_handler_655974850), "SetAnimTriggerServerRpc");
			((NetworkBehaviour)this).__registerRpc(2259893442u, new RpcReceiveHandler(__rpc_handler_2259893442), "SetAnimTriggerClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_1815470203(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;
				((VacuityRepair)(object)target).VentServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4127187543(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;
				((VacuityRepair)(object)target).VentClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2353497863(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;
				((VacuityRepair)(object)target).SitServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3589870043(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;
				((VacuityRepair)(object)target).SitClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

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

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

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "VacuityRepair";
		}
	}
	public class VCCactus : MonoBehaviour
	{
		public MeshRenderer mesh;

		public Material cactusDesert;

		public Material cactusWinter;

		public void SetCactusMaterial(bool winter)
		{
			if (winter)
			{
				((Renderer)mesh).material = cactusWinter;
			}
			else
			{
				((Renderer)mesh).material = cactusDesert;
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace bauyrsaq.Ce.Vacuity.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}
Get the Thunderstore App

Decompiled source of Vacuity Moon v1.0.6

bauyrsaq.Ce.Vacuity.dll

About

Developers
