using System;
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 GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using TerminalApi;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("MaxMarx_AdminExtensions")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("My first plugin")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MaxMarx_AdminExtensions")]
[assembly: AssemblyTitle("MaxMarx_AdminExtensions")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.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;
		}
	}
}
namespace MaxMarx_GameMaster
{
	internal enum LOG_TYPE
	{
		info,
		warning,
		error
	}
	public enum TEXT_CHAT_SENDER_TYPE
	{
		user,
		admin,
		system
	}
	[BepInPlugin("MaxMarx_AdminExtensions", "MaxMarx_AdminExtensions", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class MaxMarx_AdminExtensions : BaseUnityPlugin
	{
		private static ConfigEntry<float> configTerminalScaleValue;

		private readonly Harmony harmony = new Harmony("MaxMarx_GameMaster");

		public static bool isHost;

		public static bool enableInfiniteSprint;

		public static bool reviveSelf;

		private static bool roundStarted;

		private static bool addedCommands;

		private static bool enableDeath;

		private static bool updatedQuotaVariables;

		private static MaxMarx_AdminExtensions Instance;

		private static int patchCreditsValue;

		private static int lastCreditsValue;

		private static ManualLogSource logger;

		private static float baseTerminalScale;

		private static float patchBaseTerminalScaleValue;

		private static Dictionary<string, string> textChatColors;

		private static bool usingVirtualTerminal;

		private static bool switchRadarView;

		public static int totalAllowedPurchases;

		private static QuotaSettings newQuotaSettings;

		public static MaxNetCore net;

		private static int currentRadarIndex;

		private static PlayerControllerB thisPlayer;

		private void Awake()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			Instance = this;
			logger = ((BaseUnityPlugin)this).Logger;
			baseTerminalScale = 0f;
			patchBaseTerminalScaleValue = 0f;
			patchCreditsValue = 0;
			isHost = (roundStarted = (addedCommands = false));
			enableDeath = true;
			enableInfiniteSprint = false;
			usingVirtualTerminal = false;
			totalAllowedPurchases = 0;
			newQuotaSettings = new QuotaSettings();
			newQuotaSettings.baseIncrease = 400f;
			reviveSelf = false;
			currentRadarIndex = 0;
			switchRadarView = false;
			updatedQuotaVariables = false;
			net = null;
			harmony.PatchAll(typeof(MaxMarx_AdminExtensions));
			textChatColors = new Dictionary<string, string>
			{
				{ "red", "#ff3333" },
				{ "yellow", "#ffcc00" },
				{ "blue", "#003399" },
				{ "orange", "#ff9900" },
				{ "admin", "#66ffff" },
				{ "white", "#ffffff" },
				{ "pink", "#bb00ff" },
				{ "green", "#c1ff80" },
				{ "light-green", "#54ffc0" },
				{ "light-purple", "#e4b8ff" },
				{ "light-orange", "#ffcdb0" }
			};
			configTerminalScaleValue = ((BaseUnityPlugin)this).Config.Bind<float>("General", "TerminalScaleValue", 0f, "Value between 0.0 and 1.0 to determine scale size of terminal screen");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin MaxMarx_AdminExtensions is loaded!");
		}

		private void Update()
		{
		}

		private static void addTerminalCommands()
		{
			if (isHost)
			{
				TerminalApi.AddCommand("max", "Mini Admin Extensions Loaded\n\n", "get", false);
				TerminalApi.AddTerminalKeyword(TerminalApi.CreateTerminalKeyword("setcredits", "Setting Credits ....", true, "setCredits"));
				TerminalApi.AddTerminalKeyword(TerminalApi.CreateTerminalKeyword("setscale", "Setting Scale ....", true, "setScale"));
				TerminalApi.AddTerminalKeyword(TerminalApi.CreateTerminalKeyword("death", "Setting Death Mode ....", true, "setDeath"));
				TerminalApi.AddTerminalKeyword(TerminalApi.CreateTerminalKeyword("revive", "Reviving a player ....", true, "revivePlayer"));
				TerminalApi.AddTerminalKeyword(TerminalApi.CreateTerminalKeyword("fquota", "Setting Fulfilled Quota ....", true, "setFulfilledQuota"));
				TerminalApi.AddTerminalKeyword(TerminalApi.CreateTerminalKeyword("pquota", "Setting Profit Quota ....", true, "setProfitQuota"));
				TerminalApi.AddTerminalKeyword(TerminalApi.CreateTerminalKeyword("deadline", "Setting Deadline Days Left ....", true, "setDeadline"));
				TerminalApi.AddTerminalKeyword(TerminalApi.CreateTerminalKeyword("cp", "Pulling Player Data ....", true, "checkPlayer"));
				TerminalApi.AddTerminalKeyword(TerminalApi.CreateTerminalKeyword("q", "Switching Radar View ....", true, "switchRadarView"));
				TerminalApi.AddTerminalKeyword(TerminalApi.CreateTerminalKeyword("istamina", "Setting Infinite Stamina....", true, "setInfiniteStamina"));
				TerminalApi.AddTerminalKeyword(TerminalApi.CreateTerminalKeyword("ap", "Setting Total Allowed Purchases....", true, "chargeSpecials"));
			}
			TerminalApi.AddTerminalKeyword(TerminalApi.CreateTerminalKeyword("charge", "Charging All Battery Items....", true, "chargeSpecials"));
		}

		private static bool verifyPurchase(ref Terminal __instance)
		{
			if (!Object.op_Implicit((Object)(object)__instance) || !Object.op_Implicit((Object)(object)__instance.screenText) || __instance.screenText.text.Length == 0)
			{
				return true;
			}
			string text = __instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded);
			string text2 = __instance.screenText.text.Substring(0, __instance.screenText.text.Length - __instance.textAdded);
			if (text.Length == 0)
			{
				return true;
			}
			string[] array = text.Split(new char[1] { ' ' });
			if (array.Length == 0 || text2.Contains("The cost to route to") || text2.Contains("Routing autopilot") || text2.Contains("The Company is buying"))
			{
				return true;
			}
			string text3 = array[0];
			Terminal val = __instance;
			if (array.Length == 1 && text3.ToLower() == "confirm")
			{
				if (totalAllowedPurchases <= 0)
				{
					val.screenText.text = "DENIED ORDER";
					val.LoadNewNode(TerminalApi.CreateTerminalNode("To prevent griefing of credits, this purchase is not approved, please ask Host to approve\n\n", true, ""));
					return false;
				}
				totalAllowedPurchases--;
				net.Trigger_SyncAllowedPurchasesWithServerClient();
			}
			return true;
		}

		private static void parseTerminalCommand(ref Terminal __instance, ref TerminalNode __result, int ___totalCostOfItems)
		{
			if (!Object.op_Implicit((Object)(object)__instance) || !Object.op_Implicit((Object)(object)__instance.screenText) || __instance.screenText.text.Length == 0 || !Object.op_Implicit((Object)(object)__result))
			{
				return;
			}
			string text = __instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded);
			if (text.Length == 0)
			{
				return;
			}
			string[] array = text.Split(new char[1] { ' ' });
			if (array.Length == 0)
			{
				return;
			}
			string text2 = array[0];
			Terminal val = __instance;
			if (isHost)
			{
				if (array.Length == 2 && array[0] == "setcredits")
				{
					patchCreditsValue = int.Parse(array[1]);
					if (patchCreditsValue < 0)
					{
						patchCreditsValue = 0;
					}
					val.groupCredits = patchCreditsValue;
					__result = TerminalApi.CreateTerminalNode($"Set Credits to |{patchCreditsValue}\n\n", true, "");
				}
				if (array.Length == 2 && array[0] == "setscale")
				{
					patchBaseTerminalScaleValue = float.Parse(array[1]);
					if (patchBaseTerminalScaleValue < 0f)
					{
						patchBaseTerminalScaleValue = 0f;
					}
					if (patchBaseTerminalScaleValue > 0f)
					{
						val.terminalUIScreen.scaleFactor = baseTerminalScale + patchBaseTerminalScaleValue;
					}
					else
					{
						val.terminalUIScreen.scaleFactor = baseTerminalScale + configTerminalScaleValue.Value;
					}
					__result = TerminalApi.CreateTerminalNode($"Updated Terminal Scale [{patchBaseTerminalScaleValue}]\n\n", true, "");
				}
				if (array.Length == 2 && array[0] == "setdeath")
				{
					if (array.Length > 1 && array[1] == "1")
					{
						enableDeath = true;
					}
					else
					{
						enableDeath = false;
					}
					__result = TerminalApi.CreateTerminalNode($"Can Host Die: [{enableDeath}]\n\n", true, "");
				}
				if (array.Length == 2 && array[0] == "revive")
				{
					int num = int.Parse(array[1]);
					if (num < 0)
					{
						__result = TerminalApi.CreateTerminalNode($"No Player with Index: [{num}]\n\n", true, "");
						return;
					}
					net.Trigger_SyncReviveSelfWithServerClient((ulong)num);
					__result = TerminalApi.CreateTerminalNode($"Request Sent to revive Player Index: [{num}]\n\n", true, "");
				}
				if (array.Length == 2 && array[0] == "fquota")
				{
					int num2 = int.Parse(array[1]);
					if (num2 < 0)
					{
						return;
					}
					TimeOfDay.Instance.quotaFulfilled = num2;
					TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
					__result = TerminalApi.CreateTerminalNode($"Set New Fulfilled Quota to: [{num2}]\n\n", true, "");
				}
				if (array.Length == 2 && array[0] == "pquota")
				{
					int num3 = int.Parse(array[1]);
					if (num3 < 0)
					{
						return;
					}
					TimeOfDay.Instance.profitQuota = num3;
					TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
					__result = TerminalApi.CreateTerminalNode($"Set New Profit Quota to: [{num3}]\n\n", true, "");
				}
				if (array.Length == 2 && array[0] == "deadline")
				{
					int num4 = int.Parse(array[1]);
					if (num4 < 0)
					{
						return;
					}
					TimeOfDay.Instance.daysUntilDeadline = num4;
					((TMP_Text)StartOfRound.Instance.deadlineMonitorText).text = $"DEADLINE:\n{TimeOfDay.Instance.daysUntilDeadline} Days";
					__result = TerminalApi.CreateTerminalNode($"Set New Deadline to: [{num4}] days\nTimeUntilDeadline: {TimeOfDay.Instance.timeUntilDeadline}\nTotalTime: {TimeOfDay.Instance.totalTime}\n\n", true, "");
				}
				if (array.Length == 1 && array[0] == "q")
				{
					switchRadarView = true;
					__result = TerminalApi.CreateTerminalNode("Switched Radar View\n\n", true, "");
				}
				if (array.Length == 2 && array[0] == "cp")
				{
					int num5 = int.Parse(array[1]);
					if (num5 < 0)
					{
						__result = TerminalApi.CreateTerminalNode($"Invalid Player [{num5}]\n\n", true, "");
						return;
					}
					PlayerControllerB player = getPlayer(num5);
					if (player.playerUsername == "" || !player.isPlayerControlled)
					{
						__result = TerminalApi.CreateTerminalNode($"Invalid Player [{num5}]\n\n", true, "");
						return;
					}
					__result = TerminalApi.CreateTerminalNode($"[{player.playerUsername}] Health Is at: [{player.health}]\n\n", true, "");
				}
				if (array.Length == 2 && array[0] == "istamina")
				{
					if (array[1] == "1")
					{
						enableInfiniteSprint = true;
						net.Trigger_SyncInfiniteStaminaWithServerClient();
					}
					else
					{
						enableInfiniteSprint = false;
						net.Trigger_SyncInfiniteStaminaWithServerClient();
					}
				}
				if (array.Length == 2 && array[0] == "ap")
				{
					int num6 = int.Parse(array[1]);
					if (num6 <= 0)
					{
						return;
					}
					setTotalAllowedPurchases(num6);
				}
			}
			if (array.Length == 1 && array[0].ToLower() == "confirm")
			{
				string text3 = __result.displayText;
				int num7 = val.groupCredits - ___totalCostOfItems;
				int num8 = text3.IndexOf("Our contractors");
				if (num8 != -1)
				{
					text3 = text3.Substring(0, num8 - 1);
				}
				text3 = text3.Replace("[playerCredits]", "$" + num7);
				text3 = text3.Replace("[variableAmount]", val.playerDefinedAmount + " X ");
				text3 = text3 + "[!] Receipt from [" + thisPlayer.playerUsername + "] Stored on Server\n";
				text3 += $"[!] {totalAllowedPurchases} more purchases can be made";
				sendGeneralTextChatMessage(text3, "white", TEXT_CHAT_SENDER_TYPE.system);
			}
			if (array.Length == 1 && array[0].ToLower() == "charge")
			{
				chargeSpecialItems();
				__result = TerminalApi.CreateTerminalNode("Sent command to charge your items\n\n", true, "");
			}
			if (array.Length == 1 && array[0].ToLower() == "other")
			{
				__result.displayText = __result.displayText.Substring(0, __result.displayText.Length - 1);
				TerminalNode obj = __result;
				obj.displayText += ">CHARGE\nCharges all battery powered items in your inventory, special slots included\n";
				TerminalNode obj2 = __result;
				obj2.displayText += "\n\n";
			}
		}

		private static PlayerControllerB getPlayer(int playerID)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			for (int i = 0; i < allPlayerScripts.Length; i++)
			{
				if ((int)allPlayerScripts[i].playerClientId == playerID)
				{
					return allPlayerScripts[i];
				}
			}
			return new PlayerControllerB();
		}

		private static int LineNumber([CallerLineNumber] int lineNumber = 0)
		{
			return lineNumber;
		}

		public static void reviveThisPlayer(ref PlayerControllerB player)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			if (player.playerUsername == "" || !player.isPlayerDead)
			{
				HUDManager.Instance.DisplayTip("Unable to Revive", "[" + player.playerUsername + "] is either not dead or non-existent", false, false, "LC_Tip1");
				return;
			}
			player.ResetPlayerBloodObjects(true);
			if (player.isPlayerDead || player.isPlayerControlled)
			{
				player.isClimbingLadder = false;
				player.ResetZAndXRotation();
				((Collider)player.thisController).enabled = true;
				player.health = 100;
				player.disableLookInput = false;
				if (player.isPlayerDead)
				{
					player.isPlayerDead = false;
					player.isPlayerControlled = true;
					player.isInElevator = true;
					player.isInHangarShipRoom = true;
					player.isInsideFactory = false;
					player.wasInElevatorLastFrame = false;
					player.TeleportPlayer(instance.playerSpawnPositions[0].position, false, 0f, false, true);
					player.setPositionOfDeadPlayer = false;
					player.DisablePlayerModel(instance.allPlayerObjects[player.playerClientId], true, true);
					((Behaviour)player.helmetLight).enabled = false;
					player.Crouch(false);
					player.criticallyInjured = false;
					if ((Object)(object)player.playerBodyAnimator != (Object)null)
					{
						player.playerBodyAnimator.SetBool("Limp", false);
					}
					player.bleedingHeavily = false;
					player.activatingItem = false;
					player.twoHanded = false;
					player.inSpecialInteractAnimation = false;
					player.disableSyncInAnimation = false;
					player.inAnimationWithEnemy = null;
					player.holdingWalkieTalkie = false;
					player.speakingToWalkieTalkie = false;
					player.isSinking = false;
					player.isUnderwater = false;
					player.sinkingValue = 0f;
					player.statusEffectAudio.Stop();
					player.DisableJetpackControlsLocally();
					player.health = 100;
					player.mapRadarDotAnimator.SetBool("dead", false);
					if (((NetworkBehaviour)player).IsOwner)
					{
						HUDManager.Instance.gasHelmetAnimator.SetBool("gasEmitting", false);
						player.hasBegunSpectating = false;
						HUDManager.Instance.RemoveSpectateUI();
						HUDManager.Instance.gameOverAnimator.SetTrigger("revive");
						player.hinderedMultiplier = 1f;
						player.isMovementHindered = 0;
						player.sourcesCausingSinking = 0;
						player.reverbPreset = instance.shipReverb;
					}
				}
				SoundManager.Instance.earsRingingTimer = 0f;
				player.voiceMuffledByEnemy = false;
				SoundManager.Instance.playerVoicePitchTargets[player.playerClientId] = 1f;
				SoundManager.Instance.SetPlayerPitch(1f, (int)player.playerClientId);
				if ((Object)(object)player.currentVoiceChatIngameSettings == (Object)null)
				{
					instance.RefreshPlayerVoicePlaybackObjects();
				}
				if ((Object)(object)player.currentVoiceChatIngameSettings != (Object)null)
				{
					if ((Object)(object)player.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
					{
						player.currentVoiceChatIngameSettings.InitializeComponents();
					}
					if ((Object)(object)player.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
					{
						return;
					}
					((Component)player.currentVoiceChatIngameSettings.voiceAudio).GetComponent<OccludeAudio>().overridingLowPass = false;
				}
			}
			player.bleedingHeavily = false;
			player.criticallyInjured = false;
			player.playerBodyAnimator.SetBool("Limp", false);
			player.health = 100;
			HUDManager.Instance.UpdateHealthUI(100, false);
			player.spectatedPlayerScript = null;
			((Behaviour)HUDManager.Instance.audioListenerLowPass).enabled = false;
			instance.SetSpectateCameraToGameOverMode(false, player);
			RagdollGrabbableObject[] array = Object.FindObjectsOfType<RagdollGrabbableObject>();
			for (int i = 0; i < array.Length; i++)
			{
				if (!((GrabbableObject)array[i]).isHeld)
				{
					if (((NetworkBehaviour)instance).IsServer)
					{
						if (((NetworkBehaviour)array[i]).NetworkObject.IsSpawned)
						{
							((NetworkBehaviour)array[i]).NetworkObject.Despawn(true);
						}
						else
						{
							Object.Destroy((Object)(object)((Component)array[i]).gameObject);
						}
					}
				}
				else if (((GrabbableObject)array[i]).isHeld && (Object)(object)((GrabbableObject)array[i]).playerHeldBy != (Object)null && ((GrabbableObject)array[i]).playerHeldBy.playerClientId == player.playerClientId)
				{
					((GrabbableObject)array[i]).playerHeldBy.DropAllHeldItems(true, false);
				}
			}
			DeadBodyInfo[] array2 = Object.FindObjectsOfType<DeadBodyInfo>();
			for (int j = 0; j < array2.Length; j++)
			{
				Component val = (Component)(object)array2[j];
				if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.gameObject))
				{
					PlayerControllerB component = val.gameObject.GetComponent<PlayerControllerB>();
					if (component.playerClientId == player.playerClientId)
					{
						Object.Destroy((Object)(object)val.gameObject);
						break;
					}
				}
			}
			instance.livingPlayers++;
			instance.allPlayersDead = false;
			instance.UpdatePlayerVoiceEffects();
			instance.PlayerHasRevivedServerRpc();
			HUDManager.Instance.DisplayTip("Revive Attempted", "Admin attempted to revive you", false, false, "LC_Tip1");
		}

		public static void sendGeneralTextChatMessage(string message, string color = "white", TEXT_CHAT_SENDER_TYPE type = TEXT_CHAT_SENDER_TYPE.user)
		{
			if (message != null && !(message == ""))
			{
				message = "<color=" + textChatColors[color] + ">" + message + "</color>";
				if (type == TEXT_CHAT_SENDER_TYPE.admin)
				{
					message = "<color=" + textChatColors["admin"] + ">[ADMIN]: </color>" + message;
				}
				if (type == TEXT_CHAT_SENDER_TYPE.system)
				{
					message = "<color=" + textChatColors["admin"] + ">[SYSTEM]: </color>" + message;
				}
				HUDManager.Instance.AddTextToChatOnServer(message, -1);
			}
		}

		public static void sendTip(string header, string content)
		{
			HUDManager.Instance.DisplayTip(header, content, false, false, "LC_Tip1");
		}

		private static void log(string content, LOG_TYPE type = LOG_TYPE.info)
		{
			switch (type)
			{
			case LOG_TYPE.error:
				logger.LogError((object)content);
				FileLog.Log("[ERROR] " + content);
				break;
			case LOG_TYPE.warning:
				logger.LogWarning((object)content);
				FileLog.Log("[WARNING] " + content);
				break;
			default:
				logger.LogInfo((object)content);
				FileLog.Log("[INFO] " + content);
				break;
			}
		}

		private static void openVirtualTerminal(Terminal term)
		{
			if (!term.terminalInUse)
			{
				usingVirtualTerminal = true;
				term.BeginUsingTerminal();
				HUDManager.Instance.ChangeControlTip(0, string.Empty, true);
				GameNetworkManager.Instance.localPlayerController.inSpecialInteractAnimation = true;
				HUDManager.Instance.DisplayTip("Terminal Open", "Used !t", false, false, "LC_Tip1");
			}
		}

		private static void chargeSpecialItems()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			int num = 0;
			if (!Object.op_Implicit((Object)(object)thisPlayer) || thisPlayer.ItemSlots.Length == 0)
			{
				return;
			}
			for (int i = 0; i < thisPlayer.ItemSlots.Length; i++)
			{
				GrabbableObject val = thisPlayer.ItemSlots[i];
				if (!((Object)(object)val == (Object)null) && val.itemProperties.requiresBattery)
				{
					val.insertedBattery = new Battery(false, 1f);
					num++;
				}
			}
			if (num > 0)
			{
				sendTip("Charged Items", $"Charged {num} items in your inventory");
			}
		}

		private static void setTotalAllowedPurchases(int amount)
		{
			totalAllowedPurchases = amount;
			sendGeneralTextChatMessage($"[{amount}] purchases are approved at the terminal, buy away!", "white", TEXT_CHAT_SENDER_TYPE.system);
			net.Trigger_SyncAllowedPurchasesWithServerClient();
		}

		[HarmonyPatch(typeof(RoundManager), "LoadNewLevel")]
		[HarmonyPrefix]
		private static bool patchLoadNewLevel()
		{
			if (TimeOfDay.Instance.daysUntilDeadline == 1 && !enableInfiniteSprint)
			{
				string text = "<color=" + textChatColors["light-purple"] + ">[MAD RUSH PROJECT MANAGER] </color><color=" + textChatColors["light-orange"] + ">INFINITE Stamina! Move fast and keep your job!</color>";
				if (isHost)
				{
					HUDManager.Instance.AddTextToChatOnServer(text, -1);
				}
				enableInfiniteSprint = true;
				net.Trigger_SyncInfiniteStaminaWithServerClient();
			}
			else if (TimeOfDay.Instance.daysUntilDeadline != 1 && enableInfiniteSprint)
			{
				enableInfiniteSprint = false;
				net.Trigger_SyncInfiniteStaminaWithServerClient();
			}
			if (TimeOfDay.Instance.daysUntilDeadline == 0)
			{
				string text2 = "<color=" + textChatColors["light-purple"] + ">[MAD RUSH PROJECT MANAGER] </color><color=" + textChatColors["light-orange"] + ">Fingers crossed you don't end up in the unemployment lineup!</color>";
				if (isHost)
				{
					HUDManager.Instance.AddTextToChatOnServer(text2, -1);
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(RoundManager), "Start")]
		[HarmonyPrefix]
		private static void patchRoundManagerStart()
		{
			isHost = ((NetworkBehaviour)RoundManager.Instance).NetworkManager.IsHost;
			roundStarted = true;
			if (isHost)
			{
				Terminal val = Object.FindObjectOfType<Terminal>();
				Canvas terminalUIScreen = val.terminalUIScreen;
				val.terminalUIScreen.renderMode = (RenderMode)0;
				terminalUIScreen.scaleFactor = 1.65f;
			}
			if (isHost && roundStarted && !addedCommands)
			{
				addTerminalCommands();
				addedCommands = true;
			}
			if (!updatedQuotaVariables)
			{
				TimeOfDay.Instance.quotaVariables.baseIncrease = newQuotaSettings.baseIncrease;
				updatedQuotaVariables = true;
			}
		}

		[HarmonyPatch(typeof(Terminal), "BeginUsingTerminal")]
		[HarmonyPostfix]
		private static void patchRunTerminalEvents(ref Terminal __instance)
		{
		}

		[HarmonyPatch(typeof(Terminal), "OnSubmit")]
		[HarmonyPrefix]
		private static bool patchPurchases(ref Terminal __instance)
		{
			return verifyPurchase(ref __instance);
		}

		[HarmonyPatch(typeof(Terminal), "ParsePlayerSentence")]
		[HarmonyPostfix]
		private static void patchParseTerminalCommand(ref Terminal __instance, ref TerminalNode __result, int ___totalCostOfItems)
		{
			parseTerminalCommand(ref __instance, ref __result, ___totalCostOfItems);
		}

		[HarmonyPatch(typeof(HUDManager), "SubmitChat_performed")]
		[HarmonyPrefix]
		private static void patchSubmitChat(HUDManager __instance)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			string text = __instance.chatTextField.text;
			string text2 = "!";
			if (!text.ToLower().StartsWith(text2.ToLower()) && text.IndexOf("@") == -1)
			{
				return;
			}
			string[] array = text.Split(new char[1] { '@' });
			if (array.Length == 0)
			{
				return;
			}
			if (array[0] == "!t" && isHost)
			{
				Terminal val = Object.FindObjectOfType<Terminal>();
				if ((Object)val == (Object)null)
				{
					return;
				}
				openVirtualTerminal(val);
				__instance.chatTextField.text = "";
			}
			else if (array[0] == "!ap" && isHost && array.Length == 2)
			{
				int num = int.Parse(array[1]);
				if (num > 0)
				{
					setTotalAllowedPurchases(num);
				}
				__instance.chatTextField.text = "";
			}
			if (array.Length == 2 && array[0][0] != '!')
			{
				string color = ((!textChatColors.ContainsKey(array[0]) || ((!(array[0] == "admin") || !isHost) && !(array[0] != "admin"))) ? "white" : array[0]);
				string message = array[1];
				if (isHost)
				{
					sendGeneralTextChatMessage(message, color, TEXT_CHAT_SENDER_TYPE.admin);
				}
				else
				{
					sendGeneralTextChatMessage(message, color);
				}
				__instance.chatTextField.text = "";
			}
		}

		[HarmonyPatch(typeof(HUDManager), "AddTextToChatOnServer")]
		[HarmonyPostfix]
		private static void patchNewTextChatMessage(string chatMessage, int playerId)
		{
			string text = "";
			if (playerId != -1)
			{
				PlayerControllerB player = getPlayer(playerId);
				text = player.playerUsername;
			}
			if (isHost)
			{
				FileLog.Log("[CHAT MESSAGE][" + text + "] " + chatMessage);
			}
		}

		[HarmonyPatch(typeof(Terminal), "QuitTerminal")]
		[HarmonyPostfix]
		private static void patchQuitTerminal()
		{
			GameNetworkManager.Instance.localPlayerController.inSpecialInteractAnimation = false;
			usingVirtualTerminal = false;
		}

		[HarmonyPatch(typeof(Terminal), "LoadNewNodeIfAffordable")]
		[HarmonyPrefix]
		private static bool patchTerminalPurchases(ref Terminal __instance, ref TerminalNode node)
		{
			if (node.buyItemIndex < 0)
			{
				return true;
			}
			Item val = __instance.buyableItemsList[node.buyItemIndex];
			sendGeneralTextChatMessage($"An Order was requested for {__instance.playerDefinedAmount} X {val.itemName}", "white", TEXT_CHAT_SENDER_TYPE.system);
			return true;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "AllowPlayerDeath")]
		[HarmonyPrefix]
		private static bool patchDeath()
		{
			if (isHost)
			{
				return enableDeath;
			}
			return true;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPostfix]
		private static void patchPlayerUpdate(ref PlayerControllerB __instance, ref float ___sprintMeter, ref bool ___isCameraDisabled)
		{
			if (enableInfiniteSprint)
			{
				Mathf.Clamp(___sprintMeter += 0.02f, 0f, 1f);
			}
			if (switchRadarView)
			{
				if (currentRadarIndex >= StartOfRound.Instance.connectedPlayersAmount)
				{
					currentRadarIndex = 0;
				}
				else
				{
					currentRadarIndex++;
				}
				StartOfRound.Instance.mapScreen.SwitchRadarTargetAndSync(currentRadarIndex);
				switchRadarView = false;
			}
			if (Object.op_Implicit((Object)(object)__instance) && reviveSelf)
			{
				reviveThisPlayer(ref __instance);
				___isCameraDisabled = true;
				reviveSelf = false;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "DamagePlayerFromOtherClientServerRpc")]
		[HarmonyPostfix]
		private static void patchDetectDamageSource(ref PlayerControllerB __instance, int __2)
		{
			PlayerControllerB player = getPlayer(__2);
			string message = "<color=#E11919>" + player.playerUsername + " DAMAGED " + __instance.playerUsername + "</color>";
			sendGeneralTextChatMessage(message);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		private static void patchNewMemberJoined(ref PlayerControllerB __instance)
		{
			if (Object.op_Implicit((Object)(object)__instance) && net == null)
			{
				net = new MaxNetCore((int)__instance.playerClientId);
				thisPlayer = __instance;
				patchPlayerSettings();
				sendGeneralTextChatMessage("[" + __instance.playerUsername + "][CML] Active", "admin", TEXT_CHAT_SENDER_TYPE.system);
				sendTip("New Terminal Command(s)", "New Terminal Command(s) available, type 'HELP' and 'OTHER' to view");
			}
		}

		private static void patchPlayerSettings()
		{
			IngamePlayerSettings.Instance.settings.masterVolume = 1f;
			IngamePlayerSettings.Instance.settings.lookSensitivity = 10;
			IngamePlayerSettings.Instance.settings.micEnabled = true;
			IngamePlayerSettings.Instance.UpdateGameToMatchSettings();
		}
	}
	public class MaxNetCore
	{
		[Serializable]
		public struct MessageDataParams : INetworkSerializable
		{
			public ulong specificPlayerId;

			public int generalTarget;

			public string data;

			public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				((BufferSerializer<ulong>*)(&serializer))->SerializeValue<ulong>(ref specificPlayerId, default(ForPrimitives));
				((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref generalTarget, default(ForPrimitives));
				serializer.SerializeValue(ref data, false);
			}
		}

		private Dictionary<string, HandleNamedMessageDelegate> registeredHandlers;

		private bool initialized;

		private bool IsHost;

		private bool IsServer;

		private bool IsClient;

		public int myPlayerId;

		public MaxNetCore(int id)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			registeredHandlers = new Dictionary<string, HandleNamedMessageDelegate>
			{
				{
					"CoreExtensions-SyncAllowedPurchasesWithServerClient",
					new HandleNamedMessageDelegate(Process_SyncAllowedPurchasesWithServerClient)
				},
				{
					"CoreExtensions-SyncInfiniteStaminaWithServerClient",
					new HandleNamedMessageDelegate(Process_SyncInfiniteStaminaWithServerClient)
				},
				{
					"CoreExtensions-SyncReviveSelfWithServerClient",
					new HandleNamedMessageDelegate(Process_SyncReviveSelfWithServerClient)
				}
			};
			IsHost = (IsServer = NetworkManager.Singleton.IsHost);
			IsClient = !IsHost;
			myPlayerId = id;
			Debug.Log((object)$"[MAXNETCORE] LOCAL Player ID: {id}");
			initialized = true;
			registerMessageHandlers();
		}

		public void registerMessageHandlers()
		{
			foreach (KeyValuePair<string, HandleNamedMessageDelegate> registeredHandler in registeredHandlers)
			{
				NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler(registeredHandler.Key, registeredHandler.Value);
				Debug.Log((object)$"[MAXNETCORE] Requested Registration Network Message Handler: {registeredHandler.Key} ;;; Initialized: {initialized}");
			}
		}

		public void Trigger_SyncAllowedPurchasesWithServerClient()
		{
			MessageDataParams messageDataParams = default(MessageDataParams);
			messageDataParams.generalTarget = ((!IsHost) ? 1 : 0);
			messageDataParams.specificPlayerId = 0uL;
			messageDataParams.data = MaxMarx_AdminExtensions.totalAllowedPurchases.ToString();
			MessageDataParams data = messageDataParams;
			SendMessage("CoreExtensions-SyncAllowedPurchasesWithServerClient", data);
		}

		public void Process_SyncAllowedPurchasesWithServerClient(ulong senderId, FastBufferReader messagePayload)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			MessageDataParams messageDataParams = default(MessageDataParams);
			((FastBufferReader)(ref messagePayload)).ReadValueSafe<MessageDataParams>(ref messageDataParams, default(ForNetworkSerializable));
			int num = int.Parse(messageDataParams.data);
			if (num >= 0)
			{
				MaxMarx_AdminExtensions.totalAllowedPurchases = num;
			}
			if (IsHost)
			{
				Debug.Log((object)$"[MAXNETCORE] Server received AllowedPurchases Amount: ({messageDataParams.data}) from client ({senderId})");
				if (senderId != 0)
				{
					Debug.Log((object)$"[MAXNETCORE] Broadcasting AllowedPurchases Amount to Clients: ({messageDataParams.data}) from client ({senderId})");
					Trigger_SyncAllowedPurchasesWithServerClient();
				}
			}
			else
			{
				Debug.Log((object)("[MAXNETCORE] Client received AllowedPurchases Amount: (" + messageDataParams.data + ") from the server."));
			}
		}

		public void Trigger_SyncInfiniteStaminaWithServerClient()
		{
			if (IsHost)
			{
				MessageDataParams messageDataParams = default(MessageDataParams);
				messageDataParams.generalTarget = 0;
				messageDataParams.specificPlayerId = 0uL;
				messageDataParams.data = MaxMarx_AdminExtensions.enableInfiniteSprint.ToString();
				MessageDataParams data = messageDataParams;
				SendMessage("CoreExtensions-SyncInfiniteStaminaWithServerClient", data);
			}
		}

		public void Process_SyncInfiniteStaminaWithServerClient(ulong senderId, FastBufferReader messagePayload)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			MessageDataParams messageDataParams = default(MessageDataParams);
			((FastBufferReader)(ref messagePayload)).ReadValueSafe<MessageDataParams>(ref messageDataParams, default(ForNetworkSerializable));
			if (!IsHost)
			{
				if (messageDataParams.data == "true")
				{
					Debug.Log((object)$"[MAXNETCORE] Infinite Stamina Enabled on This Client, from server ({senderId})");
					MaxMarx_AdminExtensions.enableInfiniteSprint = true;
				}
				else
				{
					Debug.Log((object)$"[MAXNETCORE] Infinite Stamina Disabled on This Client, from server ({senderId})");
					MaxMarx_AdminExtensions.enableInfiniteSprint = false;
				}
			}
		}

		public void Trigger_SyncReviveSelfWithServerClient(ulong targetId)
		{
			if (IsHost)
			{
				MessageDataParams messageDataParams = default(MessageDataParams);
				messageDataParams.generalTarget = 2;
				messageDataParams.specificPlayerId = targetId;
				messageDataParams.data = targetId.ToString();
				MessageDataParams data = messageDataParams;
				SendMessage("CoreExtensions-SyncReviveSelfWithServerClient", data);
			}
		}

		public void Process_SyncReviveSelfWithServerClient(ulong senderId, FastBufferReader messagePayload)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			MessageDataParams messageDataParams = default(MessageDataParams);
			((FastBufferReader)(ref messagePayload)).ReadValueSafe<MessageDataParams>(ref messageDataParams, default(ForNetworkSerializable));
			if (myPlayerId == (int)messageDataParams.specificPlayerId && senderId == 0)
			{
				MaxMarx_AdminExtensions.reviveSelf = true;
				Debug.Log((object)$"[MAXNETCORE] Revive Self sent to this Client, from server ({senderId})");
			}
		}

		public void SendMessage(string messageName, MessageDataParams data)
		{
			//IL_001a: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(1100, (Allocator)2, -1);
			CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
			FastBufferWriter val2 = val;
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<MessageDataParams>(ref data, default(ForNetworkSerializable));
				if (IsServer && data.generalTarget == 0)
				{
					customMessagingManager.SendNamedMessageToAll(messageName, val, (NetworkDelivery)3);
				}
				else if (!IsServer && data.generalTarget == 1)
				{
					customMessagingManager.SendNamedMessage(messageName, 0uL, val, (NetworkDelivery)3);
				}
				else if (!IsServer && data.generalTarget == 2)
				{
					customMessagingManager.SendNamedMessage(messageName, data.specificPlayerId, val, (NetworkDelivery)3);
				}
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val2)).Dispose();
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "MaxMarx_AdminExtensions";

		public const string PLUGIN_NAME = "MaxMarx_AdminExtensions";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}