using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalCompanyInputUtils.Api;
using Microsoft.CodeAnalysis;
using OPJosMod.ReviveCompany;
using OPJosMod.ReviveCompany.CustomRpc;
using ReservedItemSlotCore.Patches;
using SpectatorChat.API;
using SpectatorChat.Other;
using SpectatorChat.Patch.Chat;
using SpectatorChat.Patch.HUD;
using SpectatorChat.Patch.Other;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("Build")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("5.0.1")]
[assembly: AssemblyInformationalVersion("3.0.0")]
[assembly: AssemblyProduct("SpectatorChat")]
[assembly: AssemblyTitle("SpectatorChat")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("5.0.1.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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace SpectatorChat
{
[BepInPlugin("Kaguya.SpectatorChat", "SpectatorChat", "1.1.8")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
public class InputKey : LcInputActions
{
[InputAction("<Keyboard>/r", Name = "ToggleDeathBox")]
public InputAction ToggleDeathBoxKey { get; set; }
}
private const string ModGuid = "Kaguya.SpectatorChat";
private const string ModName = "SpectatorChat";
private const string ModVersion = "1.1.8";
private static readonly List<string> ModId = new List<string>();
private readonly Harmony _harmony = new Harmony("Kaguya.SpectatorChat");
private static Plugin Instance;
public static ManualLogSource mls;
internal static InputKey InputActionInstance = new InputKey();
public static ConfigEntry<bool> ShowClock { get; private set; }
public static ConfigEntry<bool> CanLivingPlayerReceiveMessage { get; private set; }
public static ConfigEntry<float> CoroutineDelay { get; private set; }
public static bool KeyPressed { get; set; }
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
mls = Logger.CreateLogSource("Kaguya.SpectatorChat");
mls.LogInfo((object)"SpectatorChat has loaded.");
LoadConfigs();
PatchAll();
LogPatchInfo();
}
private void LoadSpecificPatch()
{
ModId.Add("OpJosMod.ReviveCompany");
ModId.Add("FlipMods.ReservedItemSlotCore");
((MonoBehaviour)this).StartCoroutine(WaitForDependentMod());
}
private IEnumerator WaitForDependentMod()
{
float startTime = Time.time;
float timeout = 120f;
if (!GlobalVariables.Init)
{
GlobalVariables.Init = true;
while (Time.time - startTime <= timeout)
{
Dictionary<string, PluginInfo> pluginInfos = Chainloader.PluginInfos;
int num = 0;
foreach (string key in pluginInfos.Keys)
{
if (key == "OpJosMod.ReviveCompany")
{
_harmony.PatchAll(typeof(ReviveCompanyPatch));
num++;
mls.LogInfo((object)("Detected " + key + ", Proceeding PostPatch..."));
}
else if (key == "FlipMods.ReservedItemSlotCore")
{
GlobalVariables.InitReservedItem = true;
num++;
mls.LogInfo((object)("Detected " + key + ", Proceeding..."));
}
}
mls.LogInfo((object)$"Mod found. Totally {num} Extra method were executed.");
yield return (object)new WaitForSeconds(10f);
}
}
mls.LogInfo((object)"Timeout reached or canceled.");
}
private void PatchAll()
{
_harmony.PatchAll(typeof(EnableChatPatch));
_harmony.PatchAll(typeof(SubmitChatPatch));
_harmony.PatchAll(typeof(HUDPatch));
_harmony.PatchAll(typeof(AddPlayerChatMessagePatch));
_harmony.PatchAll(typeof(HUDManagerPostfixPatch));
_harmony.PatchAll(typeof(KillPlayerPostfixPatch));
_harmony.PatchAll(typeof(HideHUDPostfixPatch));
_harmony.PatchAll(typeof(SetShipReadyToLandPostfix));
_harmony.PatchAll(typeof(KeyPatch));
LoadSpecificPatch();
}
private void LoadConfigs()
{
ShowClock = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "ShowClock", true, "Show the clock for spectator players.");
CanLivingPlayerReceiveMessage = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "CanLivingPlayerReceiveMessage", false, "Can living player receive dead player's message.");
CoroutineDelay = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "CoroutineDelay", 1f, "How long will the coroutine delay.");
mls.LogInfo((object)$"Plugin loaded with config: ShowClock: {ShowClock.Value}, CanLivingPlayerReceiveMessage: {CanLivingPlayerReceiveMessage.Value}, CoroutineDelay: {CoroutineDelay.Value}");
}
private void LogPatchInfo()
{
mls.LogInfo((object)HarmonyAPI.GetPatchInfoAsString(_harmony, AccessTools.Method(typeof(HUDManager), "Awake", (Type[])null, (Type[])null)));
mls.LogInfo((object)HarmonyAPI.GetPatchInfoAsString(_harmony, AccessTools.Method(typeof(HUDManager), "EnableChat_performed", (Type[])null, (Type[])null)));
mls.LogInfo((object)HarmonyAPI.GetPatchInfoAsString(_harmony, AccessTools.Method(typeof(HUDManager), "SubmitChat_performed", (Type[])null, (Type[])null)));
mls.LogInfo((object)HarmonyAPI.GetPatchInfoAsString(_harmony, AccessTools.Method(typeof(PlayerControllerB), "KillPlayer", (Type[])null, (Type[])null)));
mls.LogInfo((object)HarmonyAPI.GetPatchInfoAsString(_harmony, AccessTools.Method(typeof(PlayerControllerB), "Update", (Type[])null, (Type[])null)));
mls.LogInfo((object)HarmonyAPI.GetPatchInfoAsString(_harmony, AccessTools.Method(typeof(HUDManager), "HideHUD", (Type[])null, (Type[])null)));
mls.LogInfo((object)HarmonyAPI.GetPatchInfoAsString(_harmony, AccessTools.Method(typeof(StartOfRound), "SetShipReadyToLand", (Type[])null, (Type[])null)));
mls.LogInfo((object)HarmonyAPI.GetPatchInfoAsString(_harmony, AccessTools.Method(typeof(CompleteRecievedTasks), "RevivePlayer", (Type[])null, (Type[])null)));
}
}
}
namespace SpectatorChat.Patch.Other
{
internal static class HideHUDPostfixPatch
{
[HarmonyPatch(typeof(HUDManager), "HideHUD")]
private static void Postfix(HUDManager __instance)
{
HarmonyAPI.LogCallingMethod("HideHUD");
if (Generic.Instance.IsCoroutineNull())
{
return;
}
try
{
if (Generic.Instance.StopPermanentTransparent())
{
Plugin.mls.LogInfo((object)("Routine stopped successfully. Player " + GlobalVariables.PlayerControllerInstance.playerUsername));
}
else
{
Plugin.mls.LogInfo((object)("Routine stopped failed. Player " + GlobalVariables.PlayerControllerInstance.playerUsername));
}
}
catch (Exception ex)
{
Plugin.mls.LogError((object)(ex.StackTrace + ex.Message));
throw;
}
}
}
internal static class KillPlayerPostfixPatch
{
[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
private static void Postfix(PlayerControllerB __instance)
{
HarmonyAPI.LogCallingMethod("KillPlayer");
if (((NetworkBehaviour)__instance).IsOwner && Generic.Instance.StartPermanentTransparent())
{
GlobalVariables.PlayerControllerInstance.bleedingHeavily = false;
GlobalVariables.PlayerControllerInstance.criticallyInjured = false;
HUDManager.Instance.HUDAnimator.SetTrigger("revealHud");
Plugin.mls.LogInfo((object)("Routine start successfully. Player " + __instance.playerUsername));
}
}
}
internal static class ReviveCompanyPatch
{
[HarmonyPatch(typeof(CompleteRecievedTasks), "RevivePlayer")]
private static bool Prefix(ref string playerIdString)
{
HarmonyAPI.LogCallingMethod("RevivePlayer");
if (int.TryParse(playerIdString, out var result))
{
GeneralUtil.RevivePlayer(result);
if (Generic.IsInstanceOwner(playerIdString))
{
Plugin.mls.LogInfo((object)$"Player {GlobalVariables.PlayerControllerInstance.playerUsername} has been revived and IsInstanceOwner: {Generic.IsInstanceOwner(playerIdString)}");
Generic.ClearSpectatorUI(GlobalVariables.HUDManagerInstance);
if (Generic.Instance.StopPermanentTransparent())
{
Plugin.mls.LogInfo((object)("Routine stopped successfully. Player " + GlobalVariables.PlayerControllerInstance.playerUsername));
}
else
{
Plugin.mls.LogInfo((object)("Routine stopped failed. Player " + GlobalVariables.PlayerControllerInstance.playerUsername));
}
}
}
else
{
Plugin.mls.LogError((object)("Error: Invalid player ID '" + playerIdString + "' did not revive"));
}
return false;
}
}
}
namespace SpectatorChat.Patch.HUD
{
[HarmonyPatch(typeof(HUDManager), "Awake")]
internal static class HUDManagerPostfixPatch
{
private static void Postfix(HUDManager __instance)
{
HUDManager __instance2 = __instance;
HarmonyAPI.LogCallingMethod("HUDManager.Awake");
GlobalVariables.HUDManagerInstance = __instance2;
if (GlobalVariables.InitReservedItem)
{
ReservedItemUI.InitReservedItemUI();
}
if (Plugin.ShowClock.Value)
{
GlobalVariables.HUDElements = __instance2.HUDElements.Where((HUDElement element) => element != __instance2.HUDElements[1] && element != __instance2.HUDElements[5]).ToArray();
}
else
{
GlobalVariables.HUDElements = __instance2.HUDElements.Where((HUDElement element) => element != __instance2.HUDElements[1]).ToArray();
}
}
}
[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
internal static class HUDPatch
{
private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
HarmonyAPI.LogCallingMethod("KillPlayer");
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
MethodInfo hideHUDMethod = typeof(HUDManager).GetMethod("HideHUD");
Plugin.mls.LogInfo((object)"Processing KillPlayer method...");
int num;
try
{
num = list.FindLastIndex((CodeInstruction i) => i.opcode == OpCodes.Callvirt && i.operand is MethodInfo methodInfo && methodInfo.Equals(hideHUDMethod));
Plugin.mls.LogInfo((object)$"Index: {num} Code: {list[num]} found.");
num -= 2;
}
catch (Exception ex)
{
Plugin.mls.LogError((object)(ex.Message + ex.StackTrace));
throw;
}
try
{
Plugin.mls.LogInfo((object)"Patching following codes...");
for (int j = 0; j <= 2; j++)
{
Plugin.mls.LogInfo((object)$"Index: {num + j}, Code: {list[num + j]}");
list[num + j].opcode = OpCodes.Nop;
}
Plugin.mls.LogInfo((object)"Patched codes:");
for (int k = 0; k <= 2; k++)
{
Plugin.mls.LogInfo((object)$"Index: {num + k}, Code: {list[num + k]}");
}
}
catch (Exception ex2)
{
Plugin.mls.LogError((object)(ex2.Message + ex2.StackTrace));
throw;
}
finally
{
Plugin.mls.LogInfo((object)"Patch success. No any fatal error were raised.");
}
foreach (CodeInstruction item in list)
{
yield return item;
}
}
}
[HarmonyPatch(typeof(PlayerControllerB), "Update")]
internal static class KeyPatch
{
internal static void Postfix(PlayerControllerB __instance)
{
if ((!((NetworkBehaviour)__instance).IsOwner || (!__instance.isPlayerControlled && !__instance.isPlayerDead) || (((NetworkBehaviour)__instance).IsServer && !__instance.isHostPlayerObject)) && !__instance.isTestingPlayer)
{
return;
}
if ((Object)(object)GlobalVariables.PlayerControllerInstance != (Object)(object)__instance || (Object)(object)GlobalVariables.PlayerControllerInstance == (Object)null)
{
Plugin.mls.LogInfo((object)$"Player instance has changed due to {(Object)(object)GlobalVariables.PlayerControllerInstance != (Object)(object)__instance} or {(Object)(object)GlobalVariables.PlayerControllerInstance == (Object)null}");
GlobalVariables.PlayerControllerInstance = __instance;
}
if (__instance.isPlayerDead && Plugin.InputActionInstance.ToggleDeathBoxKey.WasPressedThisFrame())
{
if (!Plugin.KeyPressed)
{
Generic.ToggleSpectatorBoxUI(GlobalVariables.HUDManagerInstance, isVisable: false);
Plugin.KeyPressed = true;
}
else
{
Generic.ToggleSpectatorBoxUI(GlobalVariables.HUDManagerInstance, isVisable: true);
Plugin.KeyPressed = false;
}
}
}
}
[HarmonyPatch(typeof(StartOfRound), "SetShipReadyToLand")]
internal static class SetShipReadyToLandPostfix
{
private static void Postfix()
{
HarmonyAPI.LogCallingMethod("StartOfRound.SetShipReadyToLand");
Generic.ClearSpectatorUI(GlobalVariables.HUDManagerInstance);
}
}
}
namespace SpectatorChat.Patch.Chat
{
[HarmonyPatch(typeof(HUDManager), "AddPlayerChatMessageClientRpc")]
internal static class AddPlayerChatMessagePatch
{
private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
{
HarmonyAPI.LogCallingMethod("AddPlayerChatMessageClientRpc");
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
Label label = generator.DefineLabel();
FieldInfo targetField = typeof(PlayerControllerB).GetField("isPlayerDead");
Plugin.mls.LogInfo((object)"Processing AddPlayerChatMessageClientRpc method...");
int num;
try
{
num = list.FindLastIndex((CodeInstruction instruction) => instruction.opcode == OpCodes.Ldfld && instruction.operand is FieldInfo fieldInfo && fieldInfo.Equals(targetField));
Plugin.mls.LogInfo((object)$"Index: {num} Code: {list[num]} found.");
num -= 9;
Plugin.mls.LogInfo((object)$"Got previous IL Code: {list[num]}.");
}
catch (Exception ex)
{
Plugin.mls.LogError((object)(ex.Message + ex.StackTrace));
throw;
}
try
{
Plugin.mls.LogInfo((object)"Patching following codes...");
for (int i = 0; i <= 11; i++)
{
Plugin.mls.LogInfo((object)$"Index: {num + i}, Code: {list[num + i]}");
list[num + i].opcode = OpCodes.Nop;
}
Plugin.mls.LogInfo((object)"Patched codes:");
for (int j = 0; j <= 11; j++)
{
Plugin.mls.LogInfo((object)$"Index: {num + j}, Code: {list[num + j]}");
}
}
catch (Exception ex2)
{
Plugin.mls.LogError((object)(ex2.Message + ex2.StackTrace));
throw;
}
finally
{
Plugin.mls.LogInfo((object)"Patch success. No any fatal error were raised.");
}
Plugin.mls.LogInfo((object)"Now processing patch 2...");
try
{
num = list.FindLastIndex((CodeInstruction instruction) => instruction.opcode == OpCodes.Ldloc_0);
Plugin.mls.LogInfo((object)$"Index: {num} Code: {list[num]} found.");
num++;
Plugin.mls.LogInfo((object)$"Got next IL Code: {list[num]}.");
list[num + 1].opcode = OpCodes.Nop;
num++;
list.InsertRange(num, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[4]
{
new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(Plugin), "CanLivingPlayerReceiveMessage")),
new CodeInstruction(OpCodes.Brtrue_S, (object)label),
new CodeInstruction(OpCodes.Ret, (object)null),
CodeInstructionExtensions.WithLabels(new CodeInstruction(OpCodes.Nop, (object)null), new Label[1] { label })
});
}
catch (Exception ex3)
{
Plugin.mls.LogError((object)(ex3.Message + ex3.StackTrace));
throw;
}
finally
{
Plugin.mls.LogInfo((object)"Patch success. No any fatal error were raised.");
}
foreach (CodeInstruction item in list)
{
yield return item;
}
}
}
[HarmonyPatch(typeof(HUDManager), "EnableChat_performed")]
internal static class EnableChatPatch
{
private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
HarmonyAPI.LogCallingMethod("EnableChat_performed");
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
FieldInfo targetField = typeof(PlayerControllerB).GetField("isPlayerDead");
Plugin.mls.LogInfo((object)"Processing EnableChat_performed method...");
int num;
try
{
num = list.FindLastIndex((CodeInstruction instruction) => instruction.opcode == OpCodes.Ldfld && instruction.operand is FieldInfo fieldInfo && fieldInfo.Equals(targetField));
Plugin.mls.LogInfo((object)$"Index: {num} Code: {list[num]} found.");
num -= 2;
Plugin.mls.LogInfo((object)$"Got previous IL Code: {list[num]}.");
}
catch (Exception ex)
{
Plugin.mls.LogError((object)(ex.Message + ex.StackTrace));
throw;
}
try
{
Plugin.mls.LogInfo((object)"Patching following codes...");
for (int i = 0; i <= 4; i++)
{
Plugin.mls.LogInfo((object)$"Index: {num + i}, Code: {list[num + i]}");
list[num + i].opcode = OpCodes.Nop;
}
Plugin.mls.LogInfo((object)"Patched codes:");
for (int j = 0; j <= 4; j++)
{
Plugin.mls.LogInfo((object)$"Index: {num + j}, Code: {list[num + j]}");
}
}
catch (Exception ex2)
{
Plugin.mls.LogError((object)(ex2.Message + ex2.StackTrace));
throw;
}
finally
{
Plugin.mls.LogInfo((object)"Patch success. No any fatal error were raised.");
}
foreach (CodeInstruction item in list)
{
yield return item;
}
}
}
[HarmonyPatch(typeof(HUDManager), "SubmitChat_performed")]
internal static class SubmitChatPatch
{
private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
{
HarmonyAPI.LogCallingMethod("SubmitChat_performed");
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
FieldInfo targetField = typeof(PlayerControllerB).GetField("isPlayerDead");
Plugin.mls.LogInfo((object)"Processing SubmitChat_performed method...");
int num;
try
{
num = list.FindLastIndex((CodeInstruction instruction) => instruction.opcode == OpCodes.Ldfld && instruction.operand is FieldInfo fieldInfo && fieldInfo.Equals(targetField));
Plugin.mls.LogInfo((object)$"Index: {num} Code: {list[num]} found.");
num -= 2;
Plugin.mls.LogInfo((object)$"Got previous IL Code: {list[num]}.");
}
catch (Exception ex)
{
Plugin.mls.LogError((object)(ex.Message + ex.StackTrace));
throw;
}
try
{
Plugin.mls.LogInfo((object)"Patching following codes...");
for (int i = 0; i <= 4; i++)
{
Plugin.mls.LogInfo((object)$"Index: {num + i}, Code: {list[num + i]}");
list[num + i].opcode = OpCodes.Nop;
}
Plugin.mls.LogInfo((object)"Patched codes:");
for (int j = 0; j <= 4; j++)
{
Plugin.mls.LogInfo((object)$"Index: {num + j}, Code: {list[num + j]}");
}
}
catch (Exception ex2)
{
Plugin.mls.LogError((object)(ex2.Message + ex2.StackTrace));
throw;
}
finally
{
Plugin.mls.LogInfo((object)"Patch success. No any fatal error were raised.");
}
foreach (CodeInstruction item in list)
{
yield return item;
}
}
}
}
namespace SpectatorChat.Other
{
public static class DebugTestClass
{
public static void PrintAllVariables()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine("Global Variables State:");
stringBuilder.AppendLine($"Init: {GlobalVariables.Init}");
stringBuilder.AppendLine($"InitReservedItem: {GlobalVariables.InitReservedItem}");
stringBuilder.AppendLine("HUDElements: " + ((GlobalVariables.HUDElements != null) ? "Initialized" : "Null"));
stringBuilder.AppendLine("HUDManagerInstance: " + (((Object)(object)GlobalVariables.HUDManagerInstance != (Object)null) ? "Initialized" : "Null"));
stringBuilder.AppendLine("ReservedItemSlot: " + ((GlobalVariables.ReservedItemSlots != null) ? "Initialized" : "Null"));
stringBuilder.AppendLine("PlayerControllerInstance: " + (((Object)(object)GlobalVariables.PlayerControllerInstance != (Object)null) ? "Initialized" : "Null"));
stringBuilder.AppendLine("CoroutineCancellationTokenSource: " + ((GlobalVariables.CoroutineCancellationTokenSource != null) ? "Initialized" : "Null"));
Plugin.mls.LogInfo((object)stringBuilder.ToString());
}
}
public class GlobalVariables
{
public static CancellationTokenSource? CoroutineCancellationTokenSource;
public static bool Init { get; set; }
public static bool InitReservedItem { get; set; }
public static List<Image>? ReservedItemSlots { get; set; }
public static HUDElement[]? HUDElements { get; set; }
public static HUDManager? HUDManagerInstance { get; set; }
public static PlayerControllerB? PlayerControllerInstance { get; set; }
}
public class ReservedItemUI
{
public static void InitReservedItemUI()
{
if (Generic.IsModLoaded("FlipMods.ReservedItemSlotCore"))
{
GlobalVariables.ReservedItemSlots = HUDPatcher.reservedItemSlots;
}
else
{
GlobalVariables.ReservedItemSlots = null;
}
}
public static void SwitchReservedItemUI(bool hide)
{
if (GlobalVariables.ReservedItemSlots == null)
{
return;
}
if (hide)
{
foreach (Image reservedItemSlot in GlobalVariables.ReservedItemSlots)
{
((Behaviour)reservedItemSlot).enabled = false;
}
}
foreach (Image reservedItemSlot2 in GlobalVariables.ReservedItemSlots)
{
((Behaviour)reservedItemSlot2).enabled = true;
}
}
}
}
namespace SpectatorChat.API
{
public class Generic : MonoBehaviour
{
private static Generic? instance;
private Coroutine? _permanentTransparentCoroutine;
public static Generic Instance
{
get
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)instance == (Object)null)
{
instance = new GameObject("SpectatorChatGeneric").AddComponent<Generic>();
}
return instance;
}
}
private void Awake()
{
if ((Object)(object)instance == (Object)null)
{
instance = this;
}
else
{
instance = null;
}
}
public static bool IsInstanceOwner(string userId)
{
try
{
return ulong.Parse(userId) == GlobalVariables.PlayerControllerInstance.playerClientId;
}
catch (Exception ex)
{
Plugin.mls.LogError((object)(ex.Message + ex.StackTrace));
return false;
}
}
public bool IsCoroutineNull()
{
if (_permanentTransparentCoroutine == null)
{
return true;
}
return false;
}
public bool StartPermanentTransparent()
{
Plugin.mls.LogInfo((object)"StartPermanentTransparent() has been called.");
if (_permanentTransparentCoroutine == null)
{
Plugin.mls.LogInfo((object)"Trying to start the coroutine.");
GlobalVariables.CoroutineCancellationTokenSource = new CancellationTokenSource();
_permanentTransparentCoroutine = ((MonoBehaviour)this).StartCoroutine(PermanentTransparentCoroutine(GlobalVariables.HUDElements, GlobalVariables.CoroutineCancellationTokenSource));
return true;
}
return false;
}
public bool StopPermanentTransparent()
{
Plugin.mls.LogInfo((object)"StopPermanentTransparent() has been called.");
DebugTestClass.PrintAllVariables();
if (_permanentTransparentCoroutine != null && GlobalVariables.CoroutineCancellationTokenSource != null)
{
Plugin.mls.LogInfo((object)"Trying to stop the coroutine.");
GlobalVariables.CoroutineCancellationTokenSource.Cancel();
GlobalVariables.CoroutineCancellationTokenSource = null;
_permanentTransparentCoroutine = null;
return true;
}
return false;
}
public static bool IsModLoaded(string guid)
{
return Chainloader.PluginInfos.ContainsKey(guid);
}
private IEnumerator PermanentTransparentCoroutine(HUDElement[] elements, CancellationTokenSource coroutineCancellationTokenSource)
{
while (!coroutineCancellationTokenSource.IsCancellationRequested)
{
try
{
foreach (HUDElement val in elements)
{
if (val.canvasGroup.alpha != 0f)
{
val.canvasGroup.alpha = 0f;
}
}
if (IsModLoaded("FlipMods.ReservedItemSlotCore"))
{
ReservedItemUI.SwitchReservedItemUI(hide: true);
}
}
catch (Exception ex)
{
Plugin.mls.LogError((object)(ex.Message + ex.StackTrace));
}
yield return Plugin.CoroutineDelay.Value;
}
if (IsModLoaded("FlipMods.ReservedItemSlotCore"))
{
ReservedItemUI.SwitchReservedItemUI(hide: false);
}
_permanentTransparentCoroutine = null;
}
public static void ToggleSpectatorBoxUI(HUDManager instance, bool isVisable)
{
try
{
if (isVisable)
{
for (int i = 0; i < instance.spectatingPlayerBoxes.Count; i++)
{
((Component)instance.spectatingPlayerBoxes.ElementAt(i).Key).gameObject.SetActive(true);
}
}
else
{
for (int j = 0; j < instance.spectatingPlayerBoxes.Count; j++)
{
((Component)instance.spectatingPlayerBoxes.ElementAt(j).Key).gameObject.SetActive(false);
}
}
}
catch (Exception ex)
{
Plugin.mls.LogError((object)(ex.Message + ex.StackTrace));
throw;
}
}
public static void ClearSpectatorUI(HUDManager instance)
{
Plugin.mls.LogInfo((object)"Method ClearSpectatorUI called.");
for (int i = 0; i < instance.spectatingPlayerBoxes.Count; i++)
{
((Component)instance.spectatingPlayerBoxes.ElementAt(i).Key).gameObject.SetActive(false);
instance.boxesAdded--;
}
instance.yOffsetAmount = 0f;
instance.hasGottenPlayerSteamProfilePictures = false;
instance.hasLoadedSpectateUI = false;
instance.spectatingPlayerBoxes.Clear();
if (instance.spectatingPlayerBoxes.Count != 0)
{
Plugin.mls.LogInfo((object)"Error. spectatingPlayerBoxes not empty.");
}
}
}
public static class HarmonyAPI
{
public static string GetPatchInfoAsString(Harmony harmony, MethodInfo methodInfo)
{
MethodInfo methodInfo2 = methodInfo;
StringBuilder stringBuilder = new StringBuilder();
foreach (MethodBase item in from method in harmony.GetPatchedMethods()
where method == methodInfo2
select method)
{
stringBuilder.AppendLine("Method " + item.DeclaringType.FullName + "." + item.Name + " is patched by:");
Patches patchInfo = Harmony.GetPatchInfo(item);
foreach (Patch prefix in patchInfo.Prefixes)
{
stringBuilder.AppendLine("- Prefix: " + prefix.owner);
}
foreach (Patch postfix in patchInfo.Postfixes)
{
stringBuilder.AppendLine("- Postfix: " + postfix.owner);
}
foreach (Patch transpiler in patchInfo.Transpilers)
{
stringBuilder.AppendLine("- Transpiler: " + transpiler.owner);
}
}
return stringBuilder.ToString();
}
public static void LogCallingMethod(string patchName)
{
try
{
StackFrame[] frames = new StackTrace().GetFrames();
if (frames != null && frames.Length > 1)
{
MethodBase method = frames[1].GetMethod();
Type? declaringType = method.DeclaringType;
string text = declaringType?.Namespace;
string text2 = declaringType?.Name;
Plugin.mls.LogInfo((object)("Patch " + patchName + " called by: " + text + "." + text2 + "." + method.Name));
}
else
{
Plugin.mls.LogWarning((object)("Unable to determine calling method for patch: " + patchName));
}
}
catch (Exception ex)
{
Plugin.mls.LogError((object)("An error occurred while logging calling method for patch " + patchName + ": " + ex.Message));
}
}
}
}
