using System;
using System.Collections;
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.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Billboards.Modules;
using GameNetcodeStuff;
using HarmonyLib;
using LethalNetworkAPI;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.UI;
using UnityEngine.Video;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyCompany("UnloadedHangar")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Adds billboards to several moons")]
[assembly: AssemblyFileVersion("1.7.10.0")]
[assembly: AssemblyInformationalVersion("1.7.7+75e95b7d38c16d78266d6b3452ddfb59cc4fbbc1")]
[assembly: AssemblyProduct("Billboards")]
[assembly: AssemblyTitle("Billboards")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.7.10.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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;
		}
	}
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
public sealed class RequireNetworking : Attribute
{
	private bool isNetworkingSetUp = false;

	public RequireNetworking(bool isNetworkingSetUp)
	{
		this.isNetworkingSetUp = isNetworkingSetUp;
		if (!this.isNetworkingSetUp)
		{
			Debug.LogWarning((object)("Method '" + MethodBase.GetCurrentMethod().Name + "' requires networking, but either it has none, or the flag has the wrong value."));
		}
	}
}
namespace Billboards
{
	internal class Content
	{
		public static GameObject[] AssetsList;

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

		private static void LoadAssetsFromAssetBundle()
		{
			try
			{
				string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location);
				string text = Path.Combine(directoryName, "bilboards");
				AssetBundle val = AssetBundle.LoadFromFile(text);
				AssetsList = val.LoadAllAssets<GameObject>();
				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}");
			}
		}
	}
	public class ExternalContent : MonoBehaviour
	{
		internal static ExternalContent Instance { get; private set; }

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

		public void Start()
		{
			((MonoBehaviour)this).Invoke("DelayedStart", 2f);
		}

		private void DelayedStart()
		{
			if (BillboardControler.GetCurrentLevel() == ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.Artifice] && Plugin.ConfigManager.Artifice.Value)
			{
				((MonoBehaviour)this).StartCoroutine((IEnumerator)CoroutineStart("artifice.png"));
			}
			else if (BillboardControler.GetCurrentLevel() == ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.Assurance] && Plugin.ConfigManager.Assurance.Value)
			{
				((MonoBehaviour)this).StartCoroutine((IEnumerator)CoroutineStart("assurance.png"));
			}
			else if (BillboardControler.GetCurrentLevel() == ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.CompanyBuilding] && Plugin.ConfigManager.Company.Value)
			{
				((MonoBehaviour)this).StartCoroutine((IEnumerator)CoroutineStart("company.png"));
			}
			else if (BillboardControler.GetCurrentLevel() == ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.Experimentation] && Plugin.ConfigManager.Experimentation.Value)
			{
				((MonoBehaviour)this).StartCoroutine((IEnumerator)CoroutineStart("experimentation.png"));
			}
			else if (BillboardControler.GetCurrentLevel() == ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.Offense] && Plugin.ConfigManager.Offense.Value)
			{
				((MonoBehaviour)this).StartCoroutine((IEnumerator)CoroutineStart("offense.png"));
			}
			else if (BillboardControler.GetCurrentLevel() == ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.Titan] && Plugin.ConfigManager.Titan.Value)
			{
				((MonoBehaviour)this).StartCoroutine((IEnumerator)CoroutineStart("titan.png"));
			}
		}

		public IEnumerator<UnityWebRequestAsyncOperation> CoroutineStart(string imageToLoad)
		{
			string path = Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location);
			string convertedPath = Path.Combine(path, imageToLoad);
			UnityWebRequest www = UnityWebRequestTexture.GetTexture("file://" + convertedPath);
			yield return www.SendWebRequest();
			Texture2D texture = DownloadHandlerTexture.GetContent(www);
			((Renderer)BillboardControler.Instance.BillboardContent.GetComponent<MeshRenderer>()).material.mainTexture = (Texture)(object)texture;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("Billboards-UnloadedHangar", "Billboards", "1.7.10")]
	public class Plugin : BaseUnityPlugin
	{
		public static class PluginInfo
		{
			public const string Guid = "Billboards-UnloadedHangar";

			public const string Name = "Billboards";

			public const string Ver = "1.7.10";
		}

		internal const bool ObsoleteMethodsErroring = true;

		internal static Plugin Instance;

		internal static ManualLogSource logger;

		internal static ConfigManager ConfigManager;

		internal Harmony _harmony;

		private void Awake()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			logger = Logger.CreateLogSource("Billboards");
			logger.LogInfo((object)"Billboards has awoken!");
			ConfigManager = new ConfigManager();
			Content.Load();
			NetcodePatcherAwake();
			_harmony = new Harmony("Billboards-UnloadedHangar");
			_harmony.PatchAll(typeof(NetworkHandler));
			_harmony.PatchAll(typeof(ManagerPatchClasses));
		}

		private void NetcodePatcherAwake()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			Type[] array2 = array;
			foreach (Type type in array2)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array3 = methods;
				MethodInfo[] array4 = array3;
				foreach (MethodInfo methodInfo in array4)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
		}
	}
}
namespace Billboards.Modules
{
	public class BillboardBreakerBox : MonoBehaviour
	{
		public int leversSwitchedOff = 2;

		public bool isPowerOn;

		public BillboardControler controler;

		private VideoPlayer player;

		public Animator[] breakerSwitches;

		public AudioSource thisAudioSource;

		public AudioSource breakerBoxHum;

		public AudioClip switchPowerSFX;

		public Light breakerBoxLight;

		public MeshRenderer breakerBoxLightRenderer;

		private bool permanentlyOff = false;

		private Material[] sharedMaterialsInternal;

		public Material lightOffMaterial;

		internal static BillboardBreakerBox Instance { get; private set; }

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

		private void Start()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			player = ((Component)controler).GetComponent<VideoPlayer>();
			sharedMaterialsInternal = ((Renderer)breakerBoxLightRenderer).sharedMaterials;
			if ((Object)(object)player != (Object)null)
			{
				player.prepareCompleted += new EventHandler(PlayerReady);
			}
		}

		private void OnDestroy()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			if ((Object)(object)player != (Object)null)
			{
				player.prepareCompleted -= new EventHandler(PlayerReady);
			}
		}

		public void SwitchBreakerRPC()
		{
			NetworkHandler.SwitchBreakerMessage.SendAllClients(0, true, false);
		}

		public void SwitchBreaker(bool on)
		{
			if ((Object)(object)controler == (Object)null)
			{
				return;
			}
			if (permanentlyOff)
			{
				leversSwitchedOff--;
			}
			else
			{
				leversSwitchedOff++;
			}
			if (!permanentlyOff)
			{
				if (leversSwitchedOff <= 0)
				{
					breakerBoxHum.Play();
				}
				else if (leversSwitchedOff == 1)
				{
					breakerBoxHum.Stop();
				}
			}
			if (!permanentlyOff)
			{
				if (leversSwitchedOff <= 0 && !isPowerOn)
				{
					isPowerOn = true;
					PowerOn();
				}
				else if (leversSwitchedOff > 0 && isPowerOn)
				{
					isPowerOn = false;
					PowerOff();
				}
			}
		}

		private void PowerOff()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			player.Prepare();
			controler.BillboardContentBase.SetActive(false);
			controler.BillboardRenderTextureContent.SetActive(true);
			permanentlyOff = true;
			Landmine.SpawnExplosion(((Component)this).transform.position, true, 4f, 10f, 100, 0f, (GameObject)null, false);
			breakerBoxHum.Stop();
			((Behaviour)breakerBoxLight).enabled = false;
			sharedMaterialsInternal[1] = lightOffMaterial;
			sharedMaterialsInternal[1].color = Color.black;
			((Renderer)breakerBoxLightRenderer).sharedMaterials = sharedMaterialsInternal;
		}

		private void PowerOn()
		{
			player.Stop();
			controler.BillboardContentBase.SetActive(true);
			controler.BillboardRenderTextureContent.SetActive(false);
		}

		private void PlayerReady(VideoPlayer source)
		{
			player.Play();
		}
	}
	public class BillboardControler : MonoBehaviour
	{
		[Header("Content")]
		public GameObject BillboardRenderTextureContent;

		public GameObject BillboardContentBase;

		public GameObject BillboardContent;

		[Space]
		[Header("Misc")]
		public GameObject BillboardSupport;

		public GameObject BreakerBox;

		[Space]
		[Header("Screen materials")]
		public Material TakeyOriginalMaterial;

		public Material TakeyCaptainMaterial;

		public Material TakeyCuteMaterial;

		public Material TakeyErrorMaterial;

		public Dictionary<int, Material> BillboardScreenDictionary = new Dictionary<int, Material>();

		internal static BillboardControler Instance { get; private set; }

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

		private void Start()
		{
			ConstructDictionary();
			CalculateSpawnTransformData();
		}

		internal void TransmitContent()
		{
			if (NetworkManager.Singleton.IsHost && GetCurrentLevel() != ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.Offense])
			{
				NetworkHandler.TransmitRandomContentIdServerMessage.SendAllClients(GenerateRandomContentId(), true);
			}
		}

		internal void SetReceivedRandomContentId(int generatedId)
		{
			try
			{
				((Renderer)BillboardContent.GetComponent<MeshRenderer>()).material = BillboardScreenDictionary[generatedId];
			}
			catch (Exception ex)
			{
				Plugin.logger.LogError((object)ex);
			}
		}

		internal int GenerateRandomContentId()
		{
			return (int)Random.Range(1f, 4f);
		}

		private void ConstructDictionary()
		{
			if (GetCurrentLevel() != ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.Offense])
			{
				BillboardScreenDictionary.Add(1, TakeyOriginalMaterial);
				BillboardScreenDictionary.Add(2, TakeyCaptainMaterial);
				BillboardScreenDictionary.Add(3, TakeyCuteMaterial);
				BillboardScreenDictionary.Add(4, TakeyErrorMaterial);
			}
		}

		internal void DestroySelf()
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		internal void CalculateSpawnTransformData()
		{
			//IL_002b: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			if (GetCurrentLevel() == ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.Artifice])
			{
				SetObjectTransformData(new Vector3(24.6231f, 41.006f, -151.6691f), new Quaternion(0f, 0.59494144f, 0f, -0.80376905f));
			}
			else if (GetCurrentLevel() == ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.Assurance])
			{
				SetObjectTransformData(new Vector3(109.1466f, 33.4108f, 25.2918f), new Quaternion(0f, 0.9659258f, 0f, 0.2588191f));
			}
			else if (GetCurrentLevel() == ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.CompanyBuilding])
			{
				SetObjectTransformData(new Vector3(-20.3698f, 13.3352f, -8.2763f), new Quaternion(0f, 0f, 0.016058357f, -0.9998711f), enableBillboardSupport: false, enableBreakerBox: false);
			}
			else if (GetCurrentLevel() == ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.Experimentation])
			{
				SetObjectTransformData(new Vector3(-110.2656f, 11.7807f, -7.7252f), new Quaternion(0f, 0f, 0f, 1f), new Vector3(0.5f, 0.5f, 0.5f), 0.05f, enableBillboardSupport: false, enableBreakerBox: false);
			}
			else if (GetCurrentLevel() == ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.Offense])
			{
				SetObjectTransformData(new Vector3(51.201f, 9.7661f, -49.3033f), new Quaternion(0.55357707f, 0.7383669f, -0.23778345f, -0.3030276f), enableBillboardSupport: true, enableBreakerBox: false);
			}
			else if (GetCurrentLevel() == ManagerPatchClasses.PlanetDictionary[ManagerPatchClasses.SpawnPlanet.Titan])
			{
				SetObjectTransformData(new Vector3(-32.3487f, 67.4162f, 8.6263f), new Quaternion(0f, 0.30070576f, 0f, 0.953717f), new Vector3(0.68f, 0.68f, 0.68f), 0.15f, enableBillboardSupport: false, enableBreakerBox: false);
			}
		}

		internal static string GetCurrentLevel()
		{
			return ((object)RoundManager.Instance.currentLevel).ToString();
		}

		private void SetObjectTransformData(Vector3 position, Quaternion rotation, bool enableBillboardSupport = true, bool enableBreakerBox = true)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).gameObject.transform.position = position;
			((Component)this).gameObject.transform.rotation = rotation;
			BillboardSupport.SetActive(enableBillboardSupport);
			BreakerBox.SetActive(enableBreakerBox);
		}

		private void SetObjectTransformData(Vector3 position, Quaternion rotation, Vector3 scale, float lightRange, bool enableBillboardSupport = true, bool enableBreakerBox = true)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).gameObject.transform.position = position;
			((Component)this).gameObject.transform.rotation = rotation;
			((Component)this).gameObject.transform.localScale = scale;
			((Component)BillboardContent.transform.GetChild(0)).GetComponent<Light>().range = lightRange;
			BillboardSupport.SetActive(enableBillboardSupport);
			BreakerBox.SetActive(enableBreakerBox);
		}
	}
	internal class CompatibilityHandler
	{
		internal static bool facilityMeltdownPresent;

		internal static void OnGameLoad()
		{
			facilityMeltdownPresent = IsModPresent("me.loaforc.facilitymeltdown", "FacilityMeltdown dettected, executing integration patches...");
			if (facilityMeltdownPresent)
			{
				try
				{
					Plugin.logger.LogInfo((object)"PatchingMeltdownHandler");
				}
				catch (Exception ex)
				{
					Plugin.logger.LogError((object)ex);
				}
			}
		}

		private static bool IsModPresent(string name, string logMessage)
		{
			bool flag = Chainloader.PluginInfos.ContainsKey(name);
			if (flag)
			{
				Plugin.logger.LogInfo((object)(name + " is present. " + logMessage));
			}
			return flag;
		}
	}
	internal class ConfigManager
	{
		public ExtendedConfigEntry<bool> EnableConfiguration;

		public ExtendedConfigEntry<bool> Experimentation;

		public ExtendedConfigEntry<bool> Assurance;

		public ExtendedConfigEntry<bool> Artifice;

		public ExtendedConfigEntry<bool> Company;

		public ExtendedConfigEntry<bool> Offense;

		public ExtendedConfigEntry<bool> Titan;

		public ExtendedConfigEntry<bool> ExperimentationSpawn;

		public ExtendedConfigEntry<bool> AssuranceSpawn;

		public ExtendedConfigEntry<bool> ArtificeSpawn;

		public ExtendedConfigEntry<bool> CompanySpawn;

		public ExtendedConfigEntry<bool> OffenseSpawn;

		public ExtendedConfigEntry<bool> TitanSpawn;

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

		private void BindConfigs()
		{
			EnableConfiguration = new ExtendedConfigEntry<bool>("General Settings", "EnableConfiguration", defaultValue: false, "Enable if you want to use custom set config setting values. If disabled, the default config setting values will be used.");
			Experimentation = new ExtendedConfigEntry<bool>("General Settings", "Experimentation", defaultValue: false, "Enable custom content for experimentation billboard", useEnableConfiguration: true);
			Assurance = new ExtendedConfigEntry<bool>("General Settings", "Assurance", defaultValue: false, "Enable custom content for assurance billboard", useEnableConfiguration: true);
			Artifice = new ExtendedConfigEntry<bool>("General Settings", "Artifice", defaultValue: false, "Enable custom content for artifice billboard", useEnableConfiguration: true);
			Company = new ExtendedConfigEntry<bool>("General Settings", "Company", defaultValue: false, "Enable custom content for company billboard", useEnableConfiguration: true);
			Offense = new ExtendedConfigEntry<bool>("General Settings", "Offense", defaultValue: false, "Enable custom content for offense billboard", useEnableConfiguration: true);
			Titan = new ExtendedConfigEntry<bool>("General Settings", "Titan", defaultValue: false, "Enable custom content for titan billboard", useEnableConfiguration: true);
			ExperimentationSpawn = new ExtendedConfigEntry<bool>("Spawn Control", "ExperimentationSpawn", defaultValue: true, "Enable experimentation billboard", useEnableConfiguration: true);
			AssuranceSpawn = new ExtendedConfigEntry<bool>("Spawn Control", "AssuranceSpawn", defaultValue: true, "Enable assurance billboard", useEnableConfiguration: true);
			ArtificeSpawn = new ExtendedConfigEntry<bool>("Spawn Control", "ArtificeSpawn", defaultValue: true, "Enable artifice billboard", useEnableConfiguration: true);
			CompanySpawn = new ExtendedConfigEntry<bool>("Spawn Control", "CompanySpawn", defaultValue: true, "Enable company billboard", useEnableConfiguration: true);
			OffenseSpawn = new ExtendedConfigEntry<bool>("Spawn Control", "OffenseSpawn", defaultValue: true, "Enable offense billboard", useEnableConfiguration: true);
			TitanSpawn = new ExtendedConfigEntry<bool>("Spawn Control", "TitanSpawn", defaultValue: true, "Enable titan billboard", useEnableConfiguration: true);
		}

		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();
		}
	}
	public class ExtendedConfigEntry<T>
	{
		public ConfigEntry<T> ConfigEntry;

		public Func<T> GetValue;

		public Action<T> SetValue;

		public bool UseEnableConfiguration = false;

		public T DefaultValue => (T)((ConfigEntryBase)ConfigEntry).DefaultValue;

		public T Value
		{
			get
			{
				return GetValue();
			}
			set
			{
				SetValue(value);
			}
		}

		public ExtendedConfigEntry(string section, string key, T defaultValue, string description, bool useEnableConfiguration = false)
		{
			ConfigEntry = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<T>(section, key, defaultValue, description);
			UseEnableConfiguration = useEnableConfiguration;
			Initialize();
		}

		public ExtendedConfigEntry(string section, string key, T defaultValue, ConfigDescription configDescription = null, bool useEnableConfiguration = false)
		{
			ConfigEntry = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<T>(section, key, defaultValue, configDescription);
			UseEnableConfiguration = useEnableConfiguration;
			Initialize();
		}

		private void Initialize()
		{
			if (GetValue == null)
			{
				GetValue = () => (UseEnableConfiguration && !Plugin.ConfigManager.EnableConfiguration.Value) ? DefaultValue : ConfigEntry.Value;
			}
			if (SetValue == null)
			{
				SetValue = delegate(T value)
				{
					ConfigEntry.Value = value;
				};
			}
		}

		public void ResetToDefault()
		{
			ConfigEntry.Value = (T)((ConfigEntryBase)ConfigEntry).DefaultValue;
		}
	}
	[HarmonyPatch]
	public class ManagerPatchClasses : MonoBehaviour
	{
		public enum SpawnPlanet
		{
			Artifice,
			Assurance,
			CompanyBuilding,
			Experimentation,
			Offense,
			Titan
		}

		public enum Variant
		{
			Classic,
			Offense
		}

		public static Dictionary<SpawnPlanet, string> PlanetDictionary = new Dictionary<SpawnPlanet, string>
		{
			{
				SpawnPlanet.Artifice,
				"ArtificeLevel (SelectableLevel)"
			},
			{
				SpawnPlanet.Assurance,
				"AssuranceLevel (SelectableLevel)"
			},
			{
				SpawnPlanet.CompanyBuilding,
				"CompanyBuildingLevel (SelectableLevel)"
			},
			{
				SpawnPlanet.Experimentation,
				"ExperimentationLevel (SelectableLevel)"
			},
			{
				SpawnPlanet.Offense,
				"OffenseLevel (SelectableLevel)"
			},
			{
				SpawnPlanet.Titan,
				"TitanLevel (SelectableLevel)"
			}
		};

		internal static ManagerPatchClasses Instance { get; private set; }

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

		[HarmonyPrefix]
		[HarmonyPatch(typeof(StartOfRound), "ShipLeave")]
		private static void OnShipLeave()
		{
			DependantStaticLeave();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(StartOfRound), "StartGame")]
		private static void OnGameStart()
		{
			OnGameStartStatic();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(TimeOfDay), "Start")]
		private static void OnTimeOfDayStart()
		{
			OnTimeOfDayStartStatic();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(RoundManager), "FinishGeneratingNewLevelClientRpc")]
		private static void SendContentIdAfterGen()
		{
			if ((Object)(object)BillboardControler.Instance != (Object)null)
			{
				BillboardControler.Instance.TransmitContent();
			}
		}

		public static void DependantStaticLeave()
		{
			OnShipLeaveStatic();
		}

		public static void OnShipLeaveStatic()
		{
			if (NetworkManager.Singleton.IsHost)
			{
				try
				{
					NetworkHandler.DeSpawnBillboardServerMessage.SendAllClients(0, true);
				}
				catch (Exception arg)
				{
					Plugin.logger.LogError((object)$" Failed to run OnGameStartStatic Exception: {arg}");
				}
			}
		}

		public static void OnGameStartStatic()
		{
			if (!NetworkManager.Singleton.IsHost)
			{
				return;
			}
			try
			{
				if ((BillboardControler.GetCurrentLevel() == PlanetDictionary[SpawnPlanet.Artifice] && Plugin.ConfigManager.ArtificeSpawn.Value) || (BillboardControler.GetCurrentLevel() == PlanetDictionary[SpawnPlanet.Assurance] && Plugin.ConfigManager.AssuranceSpawn.Value) || (BillboardControler.GetCurrentLevel() == PlanetDictionary[SpawnPlanet.CompanyBuilding] && Plugin.ConfigManager.CompanySpawn.Value) || (BillboardControler.GetCurrentLevel() == PlanetDictionary[SpawnPlanet.Experimentation] && Plugin.ConfigManager.ExperimentationSpawn.Value) || (BillboardControler.GetCurrentLevel() == PlanetDictionary[SpawnPlanet.Titan] && Plugin.ConfigManager.TitanSpawn.Value))
				{
					NetworkHandler.SpawnBillboardServerMessage.SendAllClients(Variant.Classic, true);
				}
				else if (BillboardControler.GetCurrentLevel() == PlanetDictionary[SpawnPlanet.Offense] && Plugin.ConfigManager.OffenseSpawn.Value)
				{
					NetworkHandler.SpawnBillboardServerMessage.SendAllClients(Variant.Offense, true);
				}
			}
			catch (Exception arg)
			{
				Plugin.logger.LogError((object)$" Failed to run OnGameStartStatic Exception: {arg}");
			}
			NetworkHandler.NameTagServerMessage.SendAllClients(0, true);
			Plugin.logger.LogDebug((object)"GameStart");
		}

		public static void OnTimeOfDayStartStatic()
		{
			try
			{
				try
				{
					if ((Object)(object)Instance == (Object)null)
					{
						Object.Instantiate<GameObject>(Content.AssetsList[1]);
					}
					else
					{
						Plugin.logger.LogWarning((object)"Constructor was already spawned, aborting spawning duplicates to prevent errors");
					}
				}
				catch (Exception arg)
				{
					Plugin.logger.LogWarning((object)$"Failed to spawn ConstructorObject {arg}");
				}
			}
			catch (Exception arg2)
			{
				Plugin.logger.LogError((object)$"Failed to run OnTimeOfDayStartStatic() {arg2}");
			}
			Plugin.logger.LogDebug((object)"TimeOfDayStart");
		}

		public static void NothingHereDontWorryAboutIt()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB[] array = Object.FindObjectsByType<PlayerControllerB>((FindObjectsSortMode)0);
			foreach (PlayerControllerB val in array)
			{
				if ((val.playerSteamId == 76561198381652786L) | (val.playerSteamId == 76561198993712632L) | (val.playerSteamId == 76561197980238122L))
				{
					((Graphic)val.usernameBillboardText).color = Color.red;
				}
			}
		}

		[Obsolete("FacilityMeltdown integration removed", true)]
		public static void SwitchMeltdownContent(int switchToMeltdown)
		{
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			switch (switchToMeltdown)
			{
			case 0:
				flag = false;
				break;
			case 1:
				flag = true;
				break;
			}
			if (((object)RoundManager.Instance.currentLevel).ToString() == "ArtificeLevel (SelectableLevel)")
			{
				ObjectConstructor.Instance.ArtBillboardContent.SetActive(!flag);
				ObjectConstructor.Instance.ArtBillboardMeltdownContent.SetActive(flag);
			}
			else if (((object)RoundManager.Instance.currentLevel).ToString() == "AssuranceLevel (SelectableLevel)")
			{
				ObjectConstructor.Instance.AssBillboardContent.SetActive(!flag);
				ObjectConstructor.Instance.AssBillboardMeltdownContent.SetActive(flag);
			}
			else if (((object)RoundManager.Instance.currentLevel).ToString() == "CompanyBuildingLevel (SelectableLevel)")
			{
				ObjectConstructor.Instance.CompBillboardContent.SetActive(!flag);
				ObjectConstructor.Instance.CompBillboardMeltdownContent.SetActive(flag);
			}
			else if (((object)RoundManager.Instance.currentLevel).ToString() == "ExperimentationLevel (SelectableLevel)")
			{
				ObjectConstructor.Instance.ExpBillboardContent.SetActive(!flag);
				ObjectConstructor.Instance.ExpBillboardMeltdownContent.SetActive(flag);
			}
			else if (((object)RoundManager.Instance.currentLevel).ToString() == "OffenseLevel (SelectableLevel)")
			{
				((Renderer)ObjectConstructor.Instance.OffBillboardContent.gameObject.GetComponent<MeshRenderer>()).material.color = Color.grey;
			}
		}

		[Obsolete("Replaced by direct call", true)]
		public static void ArtificeBillboardClientSpawn(int data)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Content.AssetsList[data];
			Vector3 position = Content.AssetsList[data].transform.position;
			Quaternion rotation = Content.AssetsList[data].transform.rotation;
			Object.Instantiate<GameObject>(obj, position, ((Quaternion)(ref rotation)).normalized, Content.AssetsList[data].transform.parent);
		}

		[Obsolete("External object removal nolonger needed", true)]
		public static void ArtificeBillboardClientDeSpawn(int data)
		{
			switch (data)
			{
			case 0:
				Object.Destroy((Object)(object)ObjectConstructor.Instance.ArtBillboard.gameObject);
				break;
			case 1:
				Object.Destroy((Object)(object)ObjectConstructor.Instance.AssBillboard.gameObject);
				break;
			case 2:
				Object.Destroy((Object)(object)ObjectConstructor.Instance.CompBillboard.gameObject);
				break;
			case 3:
				Object.Destroy((Object)(object)ObjectConstructor.Instance.ExpBillboard.gameObject);
				break;
			case 5:
				Object.Destroy((Object)(object)ObjectConstructor.Instance.OffBillboard.gameObject);
				break;
			}
		}
	}
	[HarmonyPatch]
	internal class NetworkHandler
	{
		public static bool NetworkHandlersRegistered = false;

		public static LethalServerMessage<ManagerPatchClasses.Variant> SpawnBillboardServerMessage = new LethalServerMessage<ManagerPatchClasses.Variant>("SPAWN_BILLBOARD", (Action<ManagerPatchClasses.Variant, ulong>)null);

		public static LethalClientMessage<ManagerPatchClasses.Variant> SpawnBillboardClientMessage = new LethalClientMessage<ManagerPatchClasses.Variant>("SPAWN_BILLBOARD", (Action<ManagerPatchClasses.Variant>)null, (Action<ManagerPatchClasses.Variant, ulong>)null);

		public static LethalServerMessage<int> DeSpawnBillboardServerMessage = new LethalServerMessage<int>("DESPAWN_BILLBOARD", (Action<int, ulong>)null);

		public static LethalClientMessage<int> DeSpawnBillboardClientMessage = new LethalClientMessage<int>("DESPAWN_BILLBOARD", (Action<int>)null, (Action<int, ulong>)null);

		public static LethalServerMessage<int> TransmitRandomContentIdServerMessage = new LethalServerMessage<int>("TRANSMIT", (Action<int, ulong>)null);

		public static LethalClientMessage<int> TransmitRandomContentIdMessage = new LethalClientMessage<int>("TRANSMIT", (Action<int>)null, (Action<int, ulong>)null);

		public static LethalServerMessage<int> SwitchBreakerServerMessage = new LethalServerMessage<int>("SWITCH_BREAKER", (Action<int, ulong>)null);

		public static LethalClientMessage<int> SwitchBreakerMessage = new LethalClientMessage<int>("SWITCH_BREAKER", (Action<int>)null, (Action<int, ulong>)null);

		[Obsolete("Facility Meltdown integration removed", true)]
		public static LethalServerMessage<int> SwitchMeltdownBillboardServerMessage = new LethalServerMessage<int>("SWITCH_BILLBOARD", (Action<int, ulong>)null);

		[Obsolete("Facility Meltdown integration removed", true)]
		public static LethalClientMessage<int> SwitchMeltdownBillboardClientMessage = new LethalClientMessage<int>("SWITCH_BILLBOARD", (Action<int>)null, (Action<int, ulong>)null);

		public static LethalServerMessage<int> NameTagServerMessage = new LethalServerMessage<int>("NAMETAG", (Action<int, ulong>)null);

		public static LethalClientMessage<int> NameTagClientMessage = new LethalClientMessage<int>("NAMETAG", (Action<int>)null, (Action<int, ulong>)null);

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		public static void RegisterNetworkHandlers()
		{
			if (NetworkHandlersRegistered)
			{
				return;
			}
			try
			{
				SpawnBillboardServerMessage.OnReceived += SpawnBillboardNetworkHandlerServer;
				SpawnBillboardClientMessage.OnReceived += SpawnBillboardNetworkHandler;
				DeSpawnBillboardServerMessage.OnReceived += DeSpawnBillboardNetworkHandlerServer;
				DeSpawnBillboardClientMessage.OnReceived += DeSpawnBillboardNetworkHandler;
				NameTagServerMessage.OnReceived += NameTagNetworkHandlerServer;
				NameTagClientMessage.OnReceived += NameTagNetworkHandler;
				TransmitRandomContentIdServerMessage.OnReceived += TransmitRandomContentIdNetworkHandlerServer;
				TransmitRandomContentIdMessage.OnReceived += TransmitRandomContentIdNetworkHandler;
				SwitchBreakerServerMessage.OnReceived += SwitchBreakerNetworkHandlerServer;
				SwitchBreakerMessage.OnReceivedFromClient += SwitchBreakerNetworkHandler;
				NetworkHandlersRegistered = true;
			}
			catch (Exception arg)
			{
				Plugin.logger.LogFatal((object)$"Failed to register network handlers, Billboards mod can NOT continue... UnPatching everything! Exception: {arg}");
				HUDManager.Instance.DisplayTip("Fatal Error", "Failed to register network handlers, UnPatching!", true, false, "LC_Tip1");
				Harmony.UnpatchAll();
			}
			finally
			{
				if (NetworkHandlersRegistered)
				{
					Plugin.logger.LogDebug((object)"Registered network handlers!");
				}
			}
		}

		public static void SpawnBillboardNetworkHandler(ManagerPatchClasses.Variant data)
		{
			Plugin.logger.LogWarning((object)$"Received network message for spawn billboard result: {data}");
			HandleSpawnBillboard(data);
		}

		public static void SpawnBillboardNetworkHandlerServer(ManagerPatchClasses.Variant data, ulong empty)
		{
			Plugin.logger.LogWarning((object)$"Received network message for spawn billboard result: {data}");
			HandleSpawnBillboard(data);
		}

		public static void HandleSpawnBillboard(ManagerPatchClasses.Variant data)
		{
			switch (data)
			{
			case ManagerPatchClasses.Variant.Classic:
				Object.Instantiate<GameObject>(Content.AssetsList[0]);
				break;
			case ManagerPatchClasses.Variant.Offense:
				Object.Instantiate<GameObject>(Content.AssetsList[2]);
				break;
			}
		}

		public static void DeSpawnBillboardNetworkHandler(int data)
		{
			Plugin.logger.LogWarning((object)$"Received network message for despawn billboard result: {data}");
			HandleDeSpawnBillboard(data);
		}

		public static void DeSpawnBillboardNetworkHandlerServer(int data, ulong empty)
		{
			Plugin.logger.LogWarning((object)$"Received network message for despawn billboard result: {data}");
			HandleDeSpawnBillboard(data);
		}

		public static void HandleDeSpawnBillboard(int data)
		{
			if ((Object)(object)BillboardControler.Instance != (Object)null)
			{
				BillboardControler.Instance.DestroySelf();
			}
		}

		public static void TransmitRandomContentIdNetworkHandler(int data)
		{
			Plugin.logger.LogWarning((object)$"Received network message for transmit billboard content result: {data}");
			HandleTransmitRandomContentId(data);
		}

		public static void TransmitRandomContentIdNetworkHandlerServer(int data, ulong empty)
		{
			Plugin.logger.LogWarning((object)$"Received network message for transmit billboard content result: {data}");
			HandleTransmitRandomContentId(data);
		}

		public static void HandleTransmitRandomContentId(int data)
		{
			BillboardControler.Instance.SetReceivedRandomContentId(data);
		}

		public static void SwitchBreakerNetworkHandler(int data, ulong empty)
		{
			Plugin.logger.LogWarning((object)$"Received network message for switch breaker result: {data}");
			HandleSwitchBreaker(data);
		}

		public static void SwitchBreakerNetworkHandlerServer(int data, ulong empty)
		{
			Plugin.logger.LogWarning((object)$"Received network message for switch breaker result: {data}");
			HandleSwitchBreaker(data);
		}

		public static void HandleSwitchBreaker(int data)
		{
			BillboardBreakerBox.Instance.SwitchBreaker(on: false);
		}

		public static void SwitchMeltdownBillboardNetworkHandler(int data)
		{
			Plugin.logger.LogWarning((object)$"Received network message for switch billboard content result: {data}");
			HandleSwitchMeltdownBillboar(data);
		}

		public static void SwitchMeltdownBillboardNetworkHandlerServer(int data, ulong empty)
		{
			Plugin.logger.LogWarning((object)$"Received network message for switch billboard content result: {data}");
			HandleSwitchMeltdownBillboar(data);
		}

		public static void HandleSwitchMeltdownBillboar(int data)
		{
		}

		public static void NameTagNetworkHandler(int data)
		{
			Plugin.logger.LogWarning((object)$"Received network message for [REDACTED] result: {data}");
			HandleNameTag(data);
		}

		public static void NameTagNetworkHandlerServer(int data, ulong empty)
		{
			Plugin.logger.LogWarning((object)$"Received network message for [REDACTED] result: {data}");
			HandleNameTag(data);
		}

		public static void HandleNameTag(int data)
		{
			if (data == 0)
			{
				ManagerPatchClasses.NothingHereDontWorryAboutIt();
			}
		}
	}
	[Obsolete("Class nolonger needed", true)]
	public class ObjectConstructor : MonoBehaviour
	{
		[Obsolete("Nolonger needed", true)]
		public static ObjectConstructor Instance { get; private set; }

		[Obsolete("Replaced by object reference", true)]
		internal GameObject ArtBillboard => GameObject.Find("/Bbilboard(Clone)");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject AssBillboard => GameObject.Find("/BbilboardAss(Clone)");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject ExpBillboard => GameObject.Find("/BbilboardExper(Clone)");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject CompBillboard => GameObject.Find("/BbilboardCompany(Clone)");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject OffBillboard => GameObject.Find("/BbilboardOffenseBroken(Clone)");

		[Obsolete("Replaced by object reference", true)]
		internal static GameObject ConstructorObj => GameObject.Find("/BbilboardFrameworkConstructor(Clone)");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject AssBillboardContent => GameObject.Find("/BbilboardAss(Clone)/Cube/Content");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject AssBillboardMeltdownContent => GameObject.Find("/BbilboardAss(Clone)/Cube/MeltdownContent");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject ArtBillboardContent => GameObject.Find("/Bbilboard(Clone)/Cube/Content");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject ArtBillboardMeltdownContent => GameObject.Find("/Bbilboard(Clone)/Cube/MeltdownContent");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject ExpBillboardContent => GameObject.Find("/BbilboardExper(Clone)/Cube/Content");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject ExpBillboardMeltdownContent => GameObject.Find("/BbilboardExper(Clone)/Cube/MeltdownContent");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject CompBillboardContent => GameObject.Find("/BbilboardCompany(Clone)/Cube/Content");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject CompBillboardMeltdownContent => GameObject.Find("/BbilboardCompany(Clone)/Cube/MeltdownContent");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject OffBillboardContent => GameObject.Find("/BbilboardOffenseBroken(Clone)/BillboardDeformed2BetterFront");

		[Obsolete("Replaced by object reference", true)]
		internal GameObject OffBillboardMeltdownContent => GameObject.Find("/BbilboardOffenseBroken(Clone)/BillboardDeformed2BetterFront");

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

		[Obsolete("Moved to manager as direct call", true)]
		public static void SpawnFramework()
		{
			Object.Instantiate<GameObject>(Content.AssetsList[4]);
		}
	}
	[RequireComponent(typeof(BoxCollider))]
	public class PowerBoxHittable : MonoBehaviour, IHittable
	{
		bool IHittable.Hit(int force, Vector3 hitDirection, PlayerControllerB playerWhoHit = null, bool playHitSFX = false, int hitID = -1)
		{
			//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)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (hitID == 5)
			{
				return false;
			}
			Landmine.SpawnExplosion(((Component)this).transform.position + Vector3.up, true, 5.7f, 6f, 50, 0f, (GameObject)null, false);
			Plugin.logger.LogError((object)"Explode");
			return true;
		}
	}
}