using System; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.IO; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using BepInEx; using BepInEx.Bootstrap; using BepInEx.Configuration; using BepInEx.Logging; using GameNetcodeStuff; using HarmonyLib; using LethalConfig; using LethalConfig.ConfigItems; using LethalConfig.ConfigItems.Options; using LobbyCompatibility.Enums; using LobbyCompatibility.Features; using Microsoft.CodeAnalysis; using MonitorLabels; using MonitorLabels.BaseClasses; using MonitorLabels.Components; using MonitorLabels.Components.Tools; using MonitorLabels.Structs; using MonitorLabels.Utils; using MonitorLabels.Utils.ModUtils; using MonitorLabels.VanillaImprovements; using Monitor_Labels_Continued; using Monitor_Labels_Continued.BepInEx; using Monitor_Labels_Continued.Integrations; using Monitor_Labels_Continued.ModCompat; using Monitor_Labels_Continued.Utils; using Monitor_Labels_Continued.Utils.ExtensionMethods; using Steamworks; using Steamworks.Data; using TMPro; using Unity.Netcode; using UnityEngine; using UnityEngine.UI; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: IgnoresAccessChecksTo("Assembly-CSharp")] [assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")] [assembly: AssemblyCompany("Monitor_Labels_Continued")] [assembly: AssemblyConfiguration("Release")] [assembly: AssemblyFileVersion("1.0.0.0")] [assembly: AssemblyInformationalVersion("1.0.0")] [assembly: AssemblyProduct("Lethal Company Plugin")] [assembly: AssemblyTitle("Monitor_Labels_Continued")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("1.0.0.0")] [module: UnverifiableCode] [module: RefSafetyRules(11)] namespace Microsoft.CodeAnalysis { [CompilerGenerated] [Embedded] internal sealed class EmbeddedAttribute : Attribute { } } namespace System.Runtime.CompilerServices { [CompilerGenerated] [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 MonitorLabels { public static class AIMapLabelManager { public static readonly Dictionary CustomAINames = new Dictionary(); public static bool TryAddNewAI(Type type, CustomLabelData labelData) { return CustomAINames.TryAdd(type, labelData); } public static bool TryAddNewAI(Type type, string label, bool showLabel = true) { return CustomAINames.TryAdd(type, new CustomLabelData(label, showLabel)); } public static void SetAI(Type type, CustomLabelData customLabelData) { CustomAINames[type] = customLabelData; } public static void SetAI(Type type, string label, bool showLabel = true) { SetAI(type, new CustomLabelData(label, showLabel)); } public static void RemoveAI(Type type) { CustomAINames.Remove(type); } public static void AddLabelToAI(EnemyAI enemyAI, Transform mapDotParent, bool checkDisabledObjectsForMapDot) { //IL_008b: Unknown result type (might be due to invalid IL or missing references) //IL_009c: Unknown result type (might be due to invalid IL or missing references) //IL_0041: Unknown result type (might be due to invalid IL or missing references) //IL_0046: Unknown result type (might be due to invalid IL or missing references) //IL_004f: Unknown result type (might be due to invalid IL or missing references) //IL_0058: Unknown result type (might be due to invalid IL or missing references) //IL_0061: Unknown result type (might be due to invalid IL or missing references) //IL_0076: Unknown result type (might be due to invalid IL or missing references) bool showLabel; string aILabel = GetAILabel(enemyAI, out showLabel); if (!showLabel) { return; } Transform mapDot = MapLabelUtil.GetMapDot(mapDotParent, checkDisabledObjectsForMapDot); if (mapDot == null) { MonitorLabelsContinued.Logger.LogInfo((object)("Child MapDot cannot be found for enemy: " + ((Object)((Component)enemyAI).gameObject).name)); return; } if (enemyAI is SandSpiderAI) { Vector3 localScale = mapDot.localScale; float num = Mathf.Max(new float[3] { localScale.x, localScale.y, localScale.z }); mapDot.localScale = new Vector3(num, num, num); } TMP_Text obj = MapLabelUtil.AddLabelObject(((Component)mapDot).gameObject, BepInExConfig.EnemyLabelOffset.Value); ((Graphic)obj).color = BepInExConfig.EnemyLabelColour.Value; obj.text = aILabel; } public static void UpdateAILabel(EnemyAI enemyAI) { //IL_003c: Unknown result type (might be due to invalid IL or missing references) Transform mapDot = MapLabelUtil.GetMapDot(((Component)enemyAI).transform); if (mapDot == null) { return; } MapLabelUtil.GetRadarLabel(mapDot, out var label); if (label != null) { if (!BepInExConfig.ShowLabelOnDeadEnemies.Value) { Object.Destroy((Object)(object)((Component)label).gameObject); } else { ((Graphic)label).color = BepInExConfig.DeadEnemyLabelColour.Value; } } } private static string GetAILabel(EnemyAI enemyAI, out bool showLabel) { showLabel = true; if (!(enemyAI is BaboonBirdAI)) { if (!(enemyAI is BlobAI)) { if (!(enemyAI is CentipedeAI)) { if (!(enemyAI is CrawlerAI)) { if (!(enemyAI is RedLocustBees) && !(enemyAI is DocileLocustBeesAI)) { if (!(enemyAI is DoublewingAI)) { if (!(enemyAI is DressGirlAI)) { if (!(enemyAI is FlowermanAI)) { if (!(enemyAI is ForestGiantAI)) { if (!(enemyAI is HoarderBugAI)) { if (!(enemyAI is JesterAI)) { if (!(enemyAI is LassoManAI)) { if (!(enemyAI is MaskedPlayerEnemy)) { if (!(enemyAI is MouthDogAI)) { if (!(enemyAI is NutcrackerEnemyAI)) { if (!(enemyAI is PufferAI)) { if (!(enemyAI is SandSpiderAI)) { if (!(enemyAI is SandWormAI)) { if (!(enemyAI is SpringManAI)) { if (!(enemyAI is TestEnemy)) { if (!(enemyAI is ButlerEnemyAI)) { if (!(enemyAI is RadMechAI)) { if (!(enemyAI is FlowerSnakeEnemy)) { if (!(enemyAI is BushWolfEnemy)) { CaveDwellerAI val = (CaveDwellerAI)(object)((enemyAI is CaveDwellerAI) ? enemyAI : null); if (val == null) { if (enemyAI is ClaySurgeonAI) { return BepInExConfig.ClaySurgeonLabel.Value; } return GetUnknownAILabel(enemyAI, out showLabel); } if (!ManeaterUtil.HasTransformed(val)) { return BepInExConfig.BabyManeaterLabel.Value; } return BepInExConfig.ManeaterLabel.Value; } return BepInExConfig.BushWolfLabel.Value; } if (BepInExConfig.HideLabelOnSomeEnemies.Value) { showLabel = false; } return BepInExConfig.FlowerSnakeLabel.Value; } return BepInExConfig.RadMechLabel.Value; } return BepInExConfig.ButlerLabel.Value; } return "Obunga"; } return BepInExConfig.CoilHeadLabel.Value; } if (BepInExConfig.HideLabelOnSomeEnemies.Value) { showLabel = false; } return BepInExConfig.SandWormLabel.Value; } return BepInExConfig.SpiderLabel.Value; } return BepInExConfig.SporeLizardLabel.Value; } return BepInExConfig.NutCrackerLabel.Value; } return BepInExConfig.DogLabel.Value; } return BepInExConfig.MaskedLabel.Value; } return "Lasso"; } return BepInExConfig.JesterLabel.Value; } return BepInExConfig.HoarderBugLabel.Value; } return BepInExConfig.ForestGiantLabel.Value; } return BepInExConfig.BrackenLabel.Value; } showLabel = false; return "Girl"; } if (BepInExConfig.HideLabelOnSomeEnemies.Value) { showLabel = false; } return BepInExConfig.ManticoilLabel.Value; } showLabel = false; return "Bees"; } return BepInExConfig.CrawlerLabel.Value; } return BepInExConfig.CentipedeLabel.Value; } return BepInExConfig.BlobLabel.Value; } return BepInExConfig.BaboonHawkLabel.Value; } private static string GetUnknownAILabel(EnemyAI enemyAISubclassInstance, out bool showLabel) { foreach (KeyValuePair customAIName in CustomAINames) { if (customAIName.Key.IsInstanceOfType(enemyAISubclassInstance)) { showLabel = customAIName.Value.ShowLabel; return customAIName.Value.Label; } } showLabel = true; string value = BepInExConfig.UnknownLabel.Value; if (!value.Equals(string.Empty)) { return value; } return MapLabelUtil.RemoveCloneFromString(((Object)((Component)enemyAISubclassInstance).gameObject).name).InsertSpaceBeforeCapitals(); } } internal static class ObjectLabelManager { internal static void TryAddLabelToScrap(GrabbableObject item) { Transform radarIcon = item.radarIcon; if (!((Object)(object)radarIcon == (Object)null)) { AddLabelToScrap(item, ((Component)radarIcon).gameObject); } } internal static void UpdateScrapLabel(GrabbableObject item) { UpdateItemSlotLabel(item, null, null); } internal static void UpdateItemSlotLabel(GrabbableObject item, GrabbableObject firstToolInItemSlots, GrabbableObject firstToolInUseInItemSlots) { Transform radarIcon = item.radarIcon; if ((Object)(object)radarIcon == (Object)null && !item.itemProperties.isScrap && BepInExConfig.ShowIconOnTools.Value) { ContinuouslyUpdateToolLabel component = ((Component)item).GetComponent(); if ((Object)(object)component != (Object)null) { Object.Destroy((Object)(object)component); } ToolIconSpawner.SpawnIcon(item); radarIcon = item.radarIcon; if ((Object)(object)radarIcon != (Object)null && BepInExConfig.ShowLabelOnTools.Value) { TryAddLabelToScrap(item); } } if ((Object)(object)radarIcon == (Object)null) { return; } ContinuouslyUpdateToolLabel component2 = ((Component)item).GetComponent(); if (!((Object)(object)component2 != (Object)null) || !component2.IsUpdating) { MapLabelUtil.GetRadarLabel(radarIcon, out var label); if (label != null) { SetScrapLabel(item, label, firstToolInItemSlots, firstToolInUseInItemSlots); } } } internal static void SetScrapLabel(GrabbableObject item, TMP_Text radarLabel, GrabbableObject firstToolInItemSlots = null, GrabbableObject firstToolInUseInItemSlots = null) { //IL_0011: Unknown result type (might be due to invalid IL or missing references) radarLabel.text = GetScrapLabelString(item, out var labelColour, firstToolInItemSlots, firstToolInUseInItemSlots); ((Graphic)radarLabel).color = labelColour; } private static void AddLabelToScrap(GrabbableObject item, GameObject radarParent) { //IL_0021: 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) bool isScrap = item.itemProperties.isScrap; TMP_Text val = MapLabelUtil.AddLabelObject(radarParent, isScrap ? BepInExConfig.ScrapLabelOffset.Value : BepInExConfig.ToolLabelOffset.Value, continuouslyUpdateRotationAndOffset: false); if (isScrap) { val.fontSize *= BepInExConfig.ScrapLabelScaleFactor.Value; } else { val.fontSize = BepInExConfig.ToolLabelFontSize.Value; } SetScrapLabel(item, val); if (item.itemProperties.requiresBattery && BepInExConfig.ShowBatteryChargeOnLabel.Value) { ((Component)item).gameObject.AddComponent().Initialize(item, val); } } private static string GetScrapLabelString(GrabbableObject item, out Color labelColour, GrabbableObject firstToolInItemSlots, GrabbableObject firstToolInUseInItemSlots) { //IL_000a: Unknown result type (might be due to invalid IL or missing references) //IL_000f: Unknown result type (might be due to invalid IL or missing references) //IL_0294: Unknown result type (might be due to invalid IL or missing references) //IL_0299: Unknown result type (might be due to invalid IL or missing references) //IL_026f: Unknown result type (might be due to invalid IL or missing references) //IL_0274: Unknown result type (might be due to invalid IL or missing references) //IL_024d: Unknown result type (might be due to invalid IL or missing references) //IL_0252: Unknown result type (might be due to invalid IL or missing references) //IL_021d: Unknown result type (might be due to invalid IL or missing references) //IL_0222: Unknown result type (might be due to invalid IL or missing references) //IL_01f8: Unknown result type (might be due to invalid IL or missing references) //IL_01fd: Unknown result type (might be due to invalid IL or missing references) //IL_0058: Unknown result type (might be due to invalid IL or missing references) //IL_005d: Unknown result type (might be due to invalid IL or missing references) //IL_02bf: Unknown result type (might be due to invalid IL or missing references) //IL_02b3: Unknown result type (might be due to invalid IL or missing references) //IL_02c4: Unknown result type (might be due to invalid IL or missing references) if ((Object)(object)item == (Object)null) { labelColour = Color.white; return string.Empty; } bool flag = !item.itemProperties.isScrap; int scrapValue = item.scrapValue; if (item.isHeld) { if (flag && (Object)(object)item.playerHeldBy != (Object)null) { labelColour = BepInExConfig.CarriedToolLabelColour.Value; GrabbableObject currentlyHeldObjectServer = item.playerHeldBy.currentlyHeldObjectServer; bool flag2 = (Object)(object)currentlyHeldObjectServer != (Object)null && !currentlyHeldObjectServer.itemProperties.isScrap; if (item.isPocketed && BepInExConfig.HideToolLabelIfPocketed.Value) { if (!item.isBeingUsed || !BepInExConfig.ShowToolIfInUseAndNoOtherToolHeld.Value || flag2) { return string.Empty; } if (BepInExConfig.OnlyShow1PocketedLabel.Value) { GrabbableObject val = ((IEnumerable)item.playerHeldBy.ItemSlots).FirstOrDefault((Func)((GrabbableObject grabbableObject) => (Object)(object)grabbableObject != (Object)null && grabbableObject.isBeingUsed)); if ((Object)(object)val == (Object)null && (Object)(object)item.playerHeldBy.ItemOnlySlot != (Object)null && item.playerHeldBy.ItemOnlySlot.isBeingUsed) { val = item.playerHeldBy.ItemOnlySlot; } if ((Object)(object)item != (Object)(object)val) { return string.Empty; } } } else if (item.isPocketed && BepInExConfig.OnlyShow1PocketedLabel.Value) { if (flag2 && !BepInExConfig.HideToolLabelIfInHand.Value) { return string.Empty; } if (BepInExConfig.ShowToolIfInUseAndNoOtherToolHeld.Value) { if ((Object)(object)firstToolInUseInItemSlots != (Object)null) { if ((Object)(object)firstToolInUseInItemSlots != (Object)(object)item) { return string.Empty; } } else if ((Object)(object)firstToolInItemSlots != (Object)(object)item) { return string.Empty; } } else if ((Object)(object)item != (Object)(object)firstToolInItemSlots) { return string.Empty; } } else if (!item.isPocketed && BepInExConfig.HideToolLabelIfInHand.Value) { return string.Empty; } } else if (flag) { labelColour = BepInExConfig.CarriedToolLabelColour.Value; if (BepInExConfig.HideToolLabelIfInHand.Value) { return string.Empty; } } else { labelColour = BepInExConfig.CarriedScrapLabelColour.Value; if (BepInExConfig.HideScrapLabelIfCarried.Value) { return string.Empty; } } } else if (item.isInShipRoom) { if (flag) { labelColour = BepInExConfig.InShipToolLabelColour.Value; if (BepInExConfig.HideToolLabelIfOnShip.Value) { return string.Empty; } } else { labelColour = BepInExConfig.InShipScrapLabelColour.Value; if (BepInExConfig.HideScrapLabelIfOnShip.Value) { return string.Empty; } } } else if (flag) { labelColour = BepInExConfig.ToolLabelColour.Value; } else { labelColour = ((scrapValue >= BepInExConfig.HighValueScrapThreshold.Value) ? BepInExConfig.HighValueScrapLabelColour.Value : BepInExConfig.ScrapLabelColour.Value); } if (TryGetCustomLabel(item, out var label)) { return label; } return GetFormattedScrapLabel(item, scrapValue, flag); } private static bool TryGetCustomLabel(GrabbableObject item, out string label) { label = string.Empty; if (BepInExConfig.HideScrapLabelOnNutcracker.Value && item is ShotgunItem && item.isHeldByEnemy) { return true; } return false; } private static string GetFormattedScrapLabel(GrabbableObject item, int scrapValue, bool isTool) { string scrapName = GetScrapName(item); if (isTool) { string arg = string.Empty; if (item.itemProperties.requiresBattery && BepInExConfig.ShowBatteryChargeOnLabel.Value && item.insertedBattery != null) { float num = (item.insertedBattery.empty ? 0f : item.insertedBattery.charge); arg = string.Format(BepInExConfig.ToolBatteryStringFormat.Value, num); } return string.Format(BepInExConfig.ToolLabelStringFormat.Value, scrapName, arg); } return string.Format(BepInExConfig.ScrapLabelStringFormat.Value, scrapName, scrapValue); } private static string GetScrapName(GrabbableObject item) { Item itemProperties = item.itemProperties; if (Object.op_Implicit((Object)(object)itemProperties) && !string.IsNullOrEmpty(itemProperties.itemName)) { return itemProperties.itemName; } ScanNodeProperties componentInChildren = ((Component)item).GetComponentInChildren(); if (Object.op_Implicit((Object)(object)componentInChildren)) { return componentInChildren.headerText; } return MapLabelUtil.RemoveCloneFromString(((Object)((Component)item).gameObject).name).InsertSpaceBeforeCapitals(); } } internal static class RadarTargetLabelManager { internal static void UpdateLabel(Transform radarTargetTransform) { if (!((Object)(object)radarTargetTransform == (Object)null)) { int index; bool isCurrentRadarTarget; TransformAndName matchingRadarTarget = RadarTargetUtils.GetMatchingRadarTarget(radarTargetTransform, out index, out isCurrentRadarTarget); if (matchingRadarTarget == null || (Object)(object)matchingRadarTarget.transform == (Object)null) { MonitorLabelsContinued.Logger.LogInfo((object)"Tried to update an invalid transform!\nUpdating all radar targets to make sure everything is correct!"); UpdateLabels(); } else { AddTargetLabel(matchingRadarTarget, index, isCurrentRadarTarget); } } } internal static void UpdateLabels(int radarTargetIndex = -1) { if ((Object)(object)StartOfRound.Instance == (Object)null || (Object)(object)StartOfRound.Instance.mapScreen == (Object)null) { return; } int num = ((radarTargetIndex != -1) ? radarTargetIndex : StartOfRound.Instance.mapScreen.targetTransformIndex); for (int i = 0; i < StartOfRound.Instance.mapScreen.radarTargets.Count; i++) { bool isCurrentTarget = num == i; TransformAndName val = StartOfRound.Instance.mapScreen.radarTargets[i]; if (val != null && (Object)(object)val.transform != (Object)null) { AddTargetLabel(val, i, isCurrentTarget); } } } internal static void AddTargetLabel(TransformAndName transformAndName, int index, bool isCurrentTarget) { //IL_0113: Unknown result type (might be due to invalid IL or missing references) //IL_00eb: Unknown result type (might be due to invalid IL or missing references) PlayerControllerB component = ((Component)transformAndName.transform).gameObject.GetComponent(); Transform val = null; bool isDead = false; if ((Object)(object)component != (Object)null) { if (component.isPlayerDead) { isDead = true; if ((Object)(object)component.redirectToEnemy != (Object)null) { val = FindRadarDotOfPlayer(((Component)component.redirectToEnemy).transform); } else { if (!((Object)(object)component.deadBody != (Object)null)) { return; } val = MapLabelUtil.GetMapDot(((Component)component.deadBody).transform); } } else { val = FindRadarDotOfPlayer(((Component)component).transform); } } else { val = MapLabelUtil.GetRadarBoosterMapDot(transformAndName.transform); } if ((Object)(object)val == (Object)null) { MonitorLabelsContinued.Logger.LogInfo((object)("Cannot find radar icon for " + transformAndName.name)); return; } TMP_Text label; Transform radarLabel = MapLabelUtil.GetRadarLabel(val, out label); if ((Object)(object)label == (Object)null) { if ((Object)(object)radarLabel != (Object)null) { MonitorLabelsContinued.Logger.LogInfo((object)"The LabelObject exists but the TMP_Text component does not, this should never happen!\nDestroying the object and reinstantiating it..."); Object.Destroy((Object)(object)((Component)radarLabel).gameObject); } label = MapLabelUtil.AddLabelObject(((Component)val).gameObject, BepInExConfig.RadarTargetLabelOffset.Value); } label.text = GetLabelString(transformAndName, index, isCurrentTarget, isDead, transformAndName.isNonPlayer, component, out var labelColour); ((Graphic)label).color = labelColour; } private static string GetLabelString(TransformAndName targetName, int index, bool isTarget, bool isDead, bool isRadarBooster, PlayerControllerB playerControllerB, out Color labelColour) { //IL_000a: Unknown result type (might be due to invalid IL or missing references) //IL_000f: Unknown result type (might be due to invalid IL or missing references) //IL_005c: Unknown result type (might be due to invalid IL or missing references) //IL_0061: Unknown result type (might be due to invalid IL or missing references) //IL_00cf: Unknown result type (might be due to invalid IL or missing references) //IL_00d4: Unknown result type (might be due to invalid IL or missing references) //IL_007a: Unknown result type (might be due to invalid IL or missing references) //IL_007f: Unknown result type (might be due to invalid IL or missing references) //IL_010d: Unknown result type (might be due to invalid IL or missing references) //IL_0112: Unknown result type (might be due to invalid IL or missing references) //IL_00fc: Unknown result type (might be due to invalid IL or missing references) //IL_0101: Unknown result type (might be due to invalid IL or missing references) //IL_00a8: Unknown result type (might be due to invalid IL or missing references) //IL_00ad: Unknown result type (might be due to invalid IL or missing references) //IL_0097: Unknown result type (might be due to invalid IL or missing references) //IL_009c: Unknown result type (might be due to invalid IL or missing references) if (isDead) { labelColour = BepInExConfig.DeadPlayerLabelColour.Value; if (BepInExConfig.ForceDeadPlayerLabel.Value) { return GetRadarTargetNameString(targetName, index, isDead: true); } if (BepInExConfig.HideDeadPlayerLabels.Value || BepInExConfig.HidePlayerLabels.Value) { return string.Empty; } } else { if (!isRadarBooster && BepInExConfig.HidePlayerLabels.Value) { labelColour = Color.white; return string.Empty; } if (isTarget) { if (isRadarBooster) { labelColour = BepInExConfig.TargetRadarBoosterLabelColour.Value; } else if (BepInExConfig.UseColorsToShowPlayerHealth.Value) { labelColour = ColorCalculator.GetColorDependingOnHealth(playerControllerB, isTarget: true); } else { labelColour = Colors.GetPlayerColor(playerControllerB, isTarget: true); } if (!BepInExConfig.ShowLabelOnTarget.Value) { return string.Empty; } } else if (isRadarBooster) { labelColour = BepInExConfig.RadarBoosterLabelColour.Value; if (BepInExConfig.HideRadarBoosterLabels.Value) { return string.Empty; } } else if (BepInExConfig.UseColorsToShowPlayerHealth.Value) { labelColour = ColorCalculator.GetColorDependingOnHealth(playerControllerB, isTarget: false); } else { labelColour = Colors.GetPlayerColor(playerControllerB, isTarget: false); } } return GetRadarTargetNameString(targetName, index, isDead); } private static string GetRadarTargetNameString(TransformAndName targetTransformAndName, int index, bool isDead = false) { string text = targetTransformAndName.name; if (isDead) { string value = BepInExConfig.CustomDeadName.Value; if (value != string.Empty) { text = value; } } text = text[..Mathf.Min(text.Length, BepInExConfig.MaximumNameLength.Value)]; string arg = string.Empty; if (!targetTransformAndName.isNonPlayer && !isDead) { int currentSlotValue; int totalValueCarrying = ScrapUtil.GetTotalValueCarrying(((Component)targetTransformAndName.transform).GetComponentInParent(), out currentSlotValue); if (totalValueCarrying > 0) { arg = string.Format(BepInExConfig.PlayerCarriedScrapValueStringFormat.Value, totalValueCarrying, currentSlotValue); } } return string.Format(BepInExConfig.PlayerLabelStringFormat.Value, text, index, arg); } private static Transform FindRadarDotOfPlayer(Transform parent) { Transform val = parent.Find("Misc"); Transform val2 = val.Find("MapDot"); if (!((Object)(object)val2 != (Object)null)) { return MapLabelUtil.GetMapDot(val); } return val2; } } } namespace MonitorLabels.VanillaImprovements { public class DestroyRadarIconOnDestroy : BetterMonoBehaviour { private GrabbableObject grabbableObject; private void Awake() { grabbableObject = ((Component)this).GetComponent(); } private void OnDestroy() { if (!((Object)(object)grabbableObject == (Object)null)) { Transform radarIcon = grabbableObject.radarIcon; if (!((Object)(object)radarIcon == (Object)null)) { Object.Destroy((Object)(object)((Component)radarIcon).gameObject); grabbableObject = null; } } } } } namespace MonitorLabels.Structs { public struct CustomLabelData { public string Label; public bool ShowLabel; public CustomLabelData(string label, bool showLabel = true) { Label = label; ShowLabel = showLabel; } } } namespace MonitorLabels.Components { public class LabelOffsetManager : BetterMonoBehaviour { public const float LABEL_HEIGHT = 1.15f; public Vector2 Offset { get; set; } private void Start() { SetOffset(); } protected void SetOffset() { //IL_000b: Unknown result type (might be due to invalid IL or missing references) //IL_0010: 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_0012: Unknown result type (might be due to invalid IL or missing references) //IL_0018: 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_0027: Unknown result type (might be due to invalid IL or missing references) //IL_002c: 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) //IL_002e: Unknown result type (might be due to invalid IL or missing references) //IL_0034: Unknown result type (might be due to invalid IL or missing references) //IL_003e: Unknown result type (might be due to invalid IL or missing references) //IL_0043: Unknown result type (might be due to invalid IL or missing references) //IL_0048: Unknown result type (might be due to invalid IL or missing references) //IL_0049: Unknown result type (might be due to invalid IL or missing references) //IL_004a: Unknown result type (might be due to invalid IL or missing references) //IL_0054: Unknown result type (might be due to invalid IL or missing references) //IL_0059: Unknown result type (might be due to invalid IL or missing references) //IL_005e: Unknown result type (might be due to invalid IL or missing references) //IL_0065: Unknown result type (might be due to invalid IL or missing references) Vector3 position = base.transform.parent.position; position += MapCameraRotationObserver.MapCameraUp * Offset.y; position += MapCameraRotationObserver.MapCameraRight * Offset.x; position += Vector3.up * 1.15f; base.transform.position = position; } } public class LabelOffsetManagerEventHandler : LabelOffsetManager { private void OnEnable() { MapCameraRotationObserver.OnMapCameraRotated += base.SetOffset; } private void OnDisable() { MapCameraRotationObserver.OnMapCameraRotated -= base.SetOffset; } } public class LabelOffsetManagerContinuously : LabelOffsetManager { private void LateUpdate() { SetOffset(); } } public class MapCameraRotationObserver : BetterMonoBehaviour { public static Vector3 MapCameraUp { get; private set; } public static Vector3 MapCameraRight { get; private set; } public static Quaternion MapCameraRotation { get; private set; } public static event Action OnMapCameraRotated; private void LateUpdate() { //IL_0006: Unknown result type (might be due to invalid IL or missing references) //IL_000b: Unknown result type (might be due to invalid IL or missing references) //IL_000c: 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) Quaternion rotation = base.CachedTransform.rotation; if (!QuaternionMathUtil.IsApproximate(MapCameraRotation, rotation)) { MapCameraRotated(base.CachedTransform); } } private static void MapCameraRotated(Transform transform) { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_000c: Unknown result type (might be due to invalid IL or missing references) //IL_0017: Unknown result type (might be due to invalid IL or missing references) MapCameraUp = transform.up; MapCameraRight = transform.right; MapCameraRotation = transform.rotation; MapCameraRotationObserver.OnMapCameraRotated(); } static MapCameraRotationObserver() { //IL_0024: 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_003d: Unknown result type (might be due to invalid IL or missing references) //IL_0042: Unknown result type (might be due to invalid IL or missing references) //IL_0056: Unknown result type (might be due to invalid IL or missing references) //IL_005b: Unknown result type (might be due to invalid IL or missing references) MapCameraRotationObserver.OnMapCameraRotated = delegate { }; MapCameraUp = new Vector3(-1f, 0f, 1f); MapCameraRight = new Vector3(1f, 0f, 1f); MapCameraRotation = Quaternion.Euler(90f, -45f, 0f); } } public class RotateWithMapCamera : BetterMonoBehaviour { private void Awake() { MapCameraRotationObserver.OnMapCameraRotated += RotateWithCamera; } private void RotateWithCamera() { //IL_0006: Unknown result type (might be due to invalid IL or missing references) base.CachedTransform.rotation = MapCameraRotationObserver.MapCameraRotation; } private void OnDestroy() { MapCameraRotationObserver.OnMapCameraRotated -= RotateWithCamera; } } public class RotateWithMapCameraContinuously : BetterMonoBehaviour { public void LateUpdate() { //IL_0006: Unknown result type (might be due to invalid IL or missing references) base.CachedTransform.rotation = MapCameraRotationObserver.MapCameraRotation; } } } namespace MonitorLabels.Components.Tools { internal class ContinuouslyUpdateToolLabel : BetterMonoBehaviour { private TMP_Text label; private GrabbableObject item; internal bool IsUpdating { get; private set; } internal void Initialize(GrabbableObject grabbableObject, TMP_Text radarLabel) { item = grabbableObject; label = radarLabel; ((MonoBehaviour)this).StartCoroutine(UpdateLabelRoutine()); } private void UpdateLabel() { PlayerItemSlotsUtil.GetFirstToolAndFirstToolInUse(item.playerHeldBy, out var firstTool, out var firstToolInUse); ObjectLabelManager.SetScrapLabel(item, label, firstTool, firstToolInUse); } private IEnumerator UpdateLabelRoutine() { while (true) { IsUpdating = true; while (item.isBeingUsed) { yield return (object)new WaitForEndOfFrame(); UpdateLabel(); } IsUpdating = false; yield return (object)new WaitUntil((Func)(() => item.isBeingUsed)); } } } } namespace MonitorLabels.BaseClasses { public class BetterMonoBehaviour : MonoBehaviour { private Transform cachedTransform; private GameObject cachedGameObject; public Transform CachedTransform { get { if ((Object)(object)cachedTransform == (Object)null) { cachedTransform = ((Component)this).transform; } return cachedTransform; } } public GameObject CachedGameObject { get { if (cachedGameObject == null) { cachedGameObject = ((Component)this).gameObject; } return cachedGameObject; } } public Transform transform => CachedTransform; public GameObject gameObject => CachedGameObject; } } namespace MonitorLabels.Utils { public static class ManeaterUtil { public static bool HasTransformed(CaveDwellerAI caveDwellerAI) { return (double)caveDwellerAI.growthMeter >= 1.0; } } public static class MapLabelUtil { public const string MAP_DOT_NAME = "MapDot"; public const string RADAR_BOOSTER_DOT_NAME = "RadarBoosterDot"; public const string LABEL_OBJECT_NAME = "MapLabel"; private static readonly Vector3 labelPosition = new Vector3(0f, 0.5f, 0f); private static readonly Vector3 labelScale = new Vector3(0.5f, 0.5f, 0.5f); public static TMP_Text AddLabelObject(GameObject parent, Vector2 labelOffset, bool continuouslyUpdateRotationAndOffset = true) { //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_000b: Expected O, but got Unknown //IL_001f: 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_0034: Unknown result type (might be due to invalid IL or missing references) //IL_007a: Unknown result type (might be due to invalid IL or missing references) GameObject val = new GameObject("MapLabel"); Transform transform = val.transform; transform.SetParent(parent.transform, false); transform.localPosition = labelPosition; transform.rotation = MapCameraRotationObserver.MapCameraRotation; transform.localScale = labelScale; val.layer = parent.layer; val.tag = parent.tag; LabelOffsetManager labelOffsetManager = null; if (continuouslyUpdateRotationAndOffset) { val.AddComponent(); labelOffsetManager = val.AddComponent(); } else { val.AddComponent(); labelOffsetManager = val.AddComponent(); } labelOffsetManager.Offset = labelOffset; TextMeshPro obj = val.AddComponent(); ((TMP_Text)obj).alignment = (TextAlignmentOptions)514; ((TMP_Text)obj).autoSizeTextContainer = true; ((TMP_Text)obj).enableWordWrapping = false; ((TMP_Text)obj).overflowMode = (TextOverflowModes)0; return (TMP_Text)(object)obj; } public static Transform GetMapDot(Transform parent, bool checkDisabledObjects = false) { //IL_0015: Unknown result type (might be due to invalid IL or missing references) //IL_001b: Expected O, but got Unknown //IL_0080: Unknown result type (might be due to invalid IL or missing references) //IL_0087: Expected O, but got Unknown Queue queue = new Queue(); foreach (Transform item in parent) { Transform val = item; if (checkDisabledObjects || ((Component)val).gameObject.activeInHierarchy) { queue.Enqueue(val); } } while (queue.Count > 0) { Transform val2 = queue.Dequeue(); if (((Object)((Component)val2).gameObject).name.Contains("MapDot")) { return val2; } foreach (Transform item2 in val2) { Transform val3 = item2; if (checkDisabledObjects || ((Component)val3).gameObject.activeInHierarchy) { queue.Enqueue(val3); } } } return null; } public static Transform GetRadarLabel(Transform radarParent, out TMP_Text label) { Transform val = radarParent.Find("MapLabel"); label = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent() : null); return val; } public static Transform GetRadarBoosterMapDot(Transform radarParent) { return radarParent.Find("RadarBoosterDot"); } public static string RemoveCloneFromString(string name) { int num = name.IndexOf('('); if (num != -1) { return name.Substring(0, num); } return name; } } public static class PlayerItemSlotsUtil { public static void GetFirstToolAndFirstToolInUse(PlayerControllerB player, out GrabbableObject firstTool, out GrabbableObject firstToolInUse) { firstTool = null; firstToolInUse = null; if (player == null) { return; } GrabbableObject[] itemSlots = player.ItemSlots; foreach (GrabbableObject val in itemSlots) { if (!((Object)(object)val == (Object)null) && !val.itemProperties.isScrap) { if (firstTool == null) { firstTool = val; } if (val.isBeingUsed && firstToolInUse == null) { firstToolInUse = val; return; } } } if ((Object)(object)player.ItemOnlySlot != (Object)null && !player.ItemOnlySlot.itemProperties.isScrap) { if (firstTool == null) { firstTool = player.ItemOnlySlot; } if (player.ItemOnlySlot.isBeingUsed && firstToolInUse == null) { firstToolInUse = player.ItemOnlySlot; } } } public static void UpdateLabelsOfItemSlots(PlayerControllerB player) { if (!BepInExConfig.ShowLabelOnTools.Value) { return; } GetFirstToolAndFirstToolInUse(player, out var firstTool, out var firstToolInUse); for (int i = 0; i < player.ItemSlots.Length; i++) { GrabbableObject val = player.ItemSlots[i]; if (!((Object)(object)val == (Object)null) && !val.itemProperties.isScrap) { ObjectLabelManager.UpdateItemSlotLabel(val, firstTool, firstToolInUse); } } if ((Object)(object)player.ItemOnlySlot != (Object)null && !player.ItemOnlySlot.itemProperties.isScrap) { ObjectLabelManager.UpdateItemSlotLabel(player.ItemOnlySlot, firstTool, firstToolInUse); } } } public static class QuaternionMathUtil { public static bool IsApproximate(Quaternion lhs, Quaternion rhs, float precision = 4E-07f) { //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Unknown result type (might be due to invalid IL or missing references) return 1f - Mathf.Abs(Quaternion.Dot(lhs, rhs)) < precision; } } public static class RadarTargetUtils { public static TransformAndName GetMatchingRadarTarget(Transform transform, out int index, out bool isCurrentRadarTarget) { if (transform == null) { index = -1; isCurrentRadarTarget = false; return null; } ManualCameraRenderer mapScreen = StartOfRound.Instance.mapScreen; int targetTransformIndex = mapScreen.targetTransformIndex; for (index = 0; index < mapScreen.radarTargets.Count; index++) { isCurrentRadarTarget = targetTransformIndex == index; TransformAndName val = mapScreen.radarTargets[index]; if (val != null) { Transform transform2 = val.transform; if (transform == transform2) { return val; } } } isCurrentRadarTarget = false; return null; } } public static class ScrapUtil { public static int GetTotalValueCarrying(PlayerControllerB player, out int currentSlotValue) { currentSlotValue = 0; if (player == null) { return 0; } GrabbableObject val = null; if (player.currentItemSlot >= 0 && player.currentItemSlot < player.ItemSlots.Length) { val = player.ItemSlots[player.currentItemSlot]; } else if (player.currentItemSlot == 50) { val = player.ItemOnlySlot; } if ((Object)(object)val != (Object)null && val.itemProperties.isScrap) { currentSlotValue = val.scrapValue; } int num = player.ItemSlots.Sum((GrabbableObject item) => (!((Object)(object)item == (Object)null) && item.itemProperties.isScrap) ? item.scrapValue : 0); if ((Object)(object)player.ItemOnlySlot != (Object)null && player.ItemOnlySlot.itemProperties.isScrap) { num += player.ItemOnlySlot.scrapValue; } return num; } } public static class ToolIconSpawner { private const int mapRadarLayer = 14; private static readonly GameObject iconPrefab; static ToolIconSpawner() { AssetBundleUtil.TryLoadAsset("terminalmarker.lem", "Assets/Mods/TerminalMarker/ItemMarker.prefab", out iconPrefab); AssetBundleUtil.TryLoadAsset("terminalmarker.lem", "Assets/Mods/TerminalMarker/MarkerMaterial.mat", out Material asset); iconPrefab.GetComponent().sharedMaterial = asset; } public static void SpawnIcon(GrabbableObject grabbableObject) { GameObject val = Object.Instantiate(iconPrefab, RoundManager.Instance.mapPropsContainer.transform); ((Object)val).name = "Tool Marker (" + grabbableObject.itemProperties.itemName + ")"; val.layer = 14; grabbableObject.radarIcon = val.transform; } } } namespace MonitorLabels.Utils.ModUtils { public static class AssetBundleUtil { private static readonly string assemblyDirectory; private static readonly Dictionary loadedAssetBundles; static AssetBundleUtil() { loadedAssetBundles = new Dictionary(); assemblyDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); } public static bool TryLoadAsset(string bundleName, string assetPath, out TAssetType asset) where TAssetType : Object { if (!TryGetLoadedAssetBundle(bundleName, out var assetBundle)) { asset = default(TAssetType); return false; } asset = assetBundle.LoadAsset(assetPath); return true; } public static bool TryLoadAllAssets(string bundleName, out TAssetType[] assets) where TAssetType : Object { if (!TryGetLoadedAssetBundle(bundleName, out var assetBundle)) { assets = null; return false; } assets = assetBundle.LoadAllAssets(); return assets.Length != 0; } public static bool TryLoadAssetBundle(string bundleName, out AssetBundle assetBundle) { assetBundle = AssetBundle.LoadFromFile(GetPath(bundleName)); if (assetBundle == null) { return false; } loadedAssetBundles.Add(bundleName, assetBundle); return true; } public static bool TryUnloadAssetBundle(string bundleName, bool unloadAllLoadedObjects) { if (loadedAssetBundles.Remove(bundleName, out var value)) { value.Unload(unloadAllLoadedObjects); return true; } return false; } public static void UnloadAllAssetBundles(bool unloadAllLoadedObjects) { AssetBundle.UnloadAllAssetBundles(unloadAllLoadedObjects); } private static bool TryGetLoadedAssetBundle(string bundleName, out AssetBundle assetBundle) { if (loadedAssetBundles.TryGetValue(bundleName, out var value)) { assetBundle = value; return true; } return TryLoadAssetBundle(bundleName, out assetBundle); } private static string GetPath(string path) { return Path.Combine(assemblyDirectory, path); } } } namespace Monitor_Labels_Continued { [BepInProcess("Lethal Company.exe")] [BepInDependency(/*Could not decode attribute arguments.*/)] [BepInDependency(/*Could not decode attribute arguments.*/)] [BepInPlugin("LethalCompany.Lego.MonitorLabelContinued", "Monitor Label Continued", "3.1.5")] public class MonitorLabelsContinued : BaseUnityPlugin { internal static ManualLogSource Logger; public static MonitorLabelsContinued Instance; private void Awake() { Instance = this; Logger = ((BaseUnityPlugin)this).Logger; Logger.LogInfo((object)"Monitor Label Continued v3.1.5 Loading..."); ConfigMigration.Migrate(); ((BaseUnityPlugin)this).Config.Reload(); InitBepInEx.Init(((BaseUnityPlugin)this).Config); InitModIntegrations.Init("LethalCompany.Lego.MonitorLabelContinued", "3.1.5"); InitModCompat.Init(); Logger.LogInfo((object)"Monitor Label Continued v3.1.5 plugin fully loaded."); } } public static class MyPluginInfo { public const string PLUGIN_GUID = "Monitor_Labels_Continued"; public const string PLUGIN_NAME = "Lethal Company Plugin"; public const string PLUGIN_VERSION = "1.0.0"; } } namespace Monitor_Labels_Continued.Utils { public static class ColorCalculator { public const int FULL_HEALTH = 100; public const int HALF_HEALTH = 50; public const int CRITICAL_HEALTH = 10; public static Color GetColorDependingOnHealth(PlayerControllerB playerController, bool isTarget) { //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_000a: Unknown result type (might be due to invalid IL or missing references) //IL_0010: 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) //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) //IL_0024: Unknown result type (might be due to invalid IL or missing references) //IL_0032: Unknown result type (might be due to invalid IL or missing references) //IL_007f: Unknown result type (might be due to invalid IL or missing references) //IL_0080: Unknown result type (might be due to invalid IL or missing references) //IL_0082: Unknown result type (might be due to invalid IL or missing references) //IL_005f: Unknown result type (might be due to invalid IL or missing references) //IL_0060: Unknown result type (might be due to invalid IL or missing references) //IL_0062: Unknown result type (might be due to invalid IL or missing references) Color value = BepInExConfig.PlayerFullHealthColour.Value; Color value2 = BepInExConfig.PlayerHalfHealthColour.Value; Color value3 = BepInExConfig.PlayerCriticalHealthColour.Value; if (playerController == null) { return value; } if (playerController.health == 100) { return Colors.GetPlayerColor(playerController, isTarget); } float num = 0f; if (playerController.health >= 50) { num = Mathf.InverseLerp(50f, 100f, (float)playerController.health); return Color.Lerp(value2, value, num); } num = Mathf.InverseLerp(10f, 50f, (float)playerController.health); return Color.Lerp(value3, value2, num); } } public static class ConfigMigration { private static float lastMigrationClickTime; public static void Migrate() { try { string configPath = Paths.ConfigPath; string text = Path.Combine(configPath, "DannyVD.mods.LethalCompany.MonitorLabels.cfg"); string text2 = Path.Combine(configPath, "LethalComapny.Lego.MonitorLabelContinued.cfg"); string text3 = Path.Combine(configPath, "LethalCompany.Lego.MonitorLabelContinued.cfg"); if (!File.Exists(text3)) { if (File.Exists(text2)) { File.Move(text2, text3); MonitorLabelsContinued.Logger.LogInfo((object)"Successfully migrated and renamed misspelled configuration file (v3.0.0 -> v3.0.1)"); } else if (File.Exists(text)) { File.Copy(text, text3); MonitorLabelsContinued.Logger.LogInfo((object)"Successfully copied and migrated settings from the original MonitorLabels mod"); } } } catch (Exception ex) { MonitorLabelsContinued.Logger.LogWarning((object)("Failed to run configuration migration: " + ex.Message)); } } public static void RequestMigration() { try { string configPath = Paths.ConfigPath; string text = Path.Combine(configPath, "DannyVD.mods.LethalCompany.MonitorLabels.cfg"); string destFileName = Path.Combine(configPath, "LethalCompany.Lego.MonitorLabelContinued.cfg"); if (File.Exists(text)) { float realtimeSinceStartup = Time.realtimeSinceStartup; if (realtimeSinceStartup - lastMigrationClickTime > 3f) { lastMigrationClickTime = realtimeSinceStartup; return; } lastMigrationClickTime = 0f; File.Copy(text, destFileName, overwrite: true); ((BaseUnityPlugin)MonitorLabelsContinued.Instance).Config.Reload(); BepInExConfig.ReadConfig(); MonitorLabelsContinued.Logger.LogInfo((object)"Successfully migrated and applied settings from the original MonitorLabels mod!"); } } catch (Exception ex) { MonitorLabelsContinued.Logger.LogWarning((object)("Failed to run configuration migration request: " + ex.Message)); } } } internal class Constants { public const string CUSTOM_PLAYER_COLOR_METADATA_KEY = "MonitorLabelsContinued_CustomPlayerLabelColor"; } internal static class PluginInfos { public const string PLUGIN_NAME = "Monitor Label Continued"; public const string PLUGIN_GUID = "LethalCompany.Lego.MonitorLabelContinued"; public const string PLUGIN_VERSION = "3.1.5"; } public static class SteamIDs { public const ulong ORIGINAL_DEV_ID = 76561198166372065uL; public const ulong CONTINUED_DEV_ID = 76561198368204860uL; } public static class Colors { public static readonly Color OriginalDevColor = new Color(0.52f, 0f, 0.56f); public static readonly Color ContinuedDevColor = new Color(0.81f, 0.34f, 1f); public static readonly string ContinuedDevColorHex = "#" + ColorUtility.ToHtmlStringRGB(ContinuedDevColor).ToLower(); public static Color GetPlayerColor(PlayerControllerB player, bool isTarget) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) //IL_00ad: 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) //IL_00c6: Unknown result type (might be due to invalid IL or missing references) //IL_00bb: Unknown result type (might be due to invalid IL or missing references) //IL_0065: Unknown result type (might be due to invalid IL or missing references) //IL_006a: Unknown result type (might be due to invalid IL or missing references) //IL_0071: Unknown result type (might be due to invalid IL or missing references) //IL_0076: Unknown result type (might be due to invalid IL or missing references) //IL_0079: 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_00a2: Unknown result type (might be due to invalid IL or missing references) //IL_00a4: Unknown result type (might be due to invalid IL or missing references) //IL_00cc: Unknown result type (might be due to invalid IL or missing references) if ((Object)(object)player == (Object)null) { return Color.white; } if (player.playerSteamId == 76561198166372065L) { return OriginalDevColor; } if (player.playerSteamId == 76561198368204860L) { if ((Object)(object)GameNetworkManager.Instance != (Object)null && GameNetworkManager.Instance.currentLobby.HasValue) { try { Lobby value = GameNetworkManager.Instance.currentLobby.Value; SteamId val = SteamId.op_Implicit(player.playerSteamId); Friend val2 = default(Friend); ((Friend)(ref val2))..ctor(val); string memberData = ((Lobby)(ref value)).GetMemberData(val2, "MonitorLabelsContinued_CustomPlayerLabelColor"); Color result = default(Color); if (!string.IsNullOrEmpty(memberData) && ColorUtility.TryParseHtmlString(memberData, ref result)) { return result; } } catch { } } return ContinuedDevColor; } if (!isTarget) { return BepInExConfig.DefaultPlayerLabelColour.Value; } return BepInExConfig.TargetPlayerLabelColour.Value; } } } namespace Monitor_Labels_Continued.Utils.ExtensionMethods { public static class StringExtensions { public static string InsertSpaceBeforeCapitals(this string text) { if (string.IsNullOrEmpty(text)) { return text; } string text2 = text.ToUpper(); string text3 = text; if (text.Length == 1) { return text3; } for (int num = text.Length - 1; num >= 1; num--) { if (text[num] == text2[num]) { text3 = text3.Insert(num, " "); } } return text3; } } } namespace Monitor_Labels_Continued.Integrations { internal class InitModIntegrations { public static void Init(string pluginGuid, string pluginVersion) { if (Chainloader.PluginInfos.ContainsKey("BMX.LobbyCompatibility")) { LobbyCompatModIntegration.Register(pluginGuid, pluginVersion); } else { MonitorLabelsContinued.Logger.LogInfo((object)"LobbyCompatibility not detected. Skipping compatibility registration."); } if (Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig")) { LethalConfigIntegration.Init(); } else { MonitorLabelsContinued.Logger.LogInfo((object)"LethalConfig not detected. Skipping custom menu setup."); } } } internal class LethalConfigIntegration { [CompilerGenerated] private static class <>O { public static GenericButtonHandler <0>__ApplyChanges; public static GenericButtonHandler <1>__RequestMigration; } [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)] public static void Init() { //IL_0035: Unknown result type (might be due to invalid IL or missing references) //IL_003b: Expected O, but got Unknown //IL_00aa: Unknown result type (might be due to invalid IL or missing references) //IL_00b4: Expected O, but got Unknown //IL_009f: Unknown result type (might be due to invalid IL or missing references) //IL_00a4: Unknown result type (might be due to invalid IL or missing references) //IL_00aa: Expected O, but got Unknown //IL_005d: Unknown result type (might be due to invalid IL or missing references) //IL_006c: Unknown result type (might be due to invalid IL or missing references) //IL_00e3: Unknown result type (might be due to invalid IL or missing references) //IL_00ed: Expected O, but got Unknown //IL_00d8: Unknown result type (might be due to invalid IL or missing references) //IL_00dd: Unknown result type (might be due to invalid IL or missing references) //IL_00e3: Expected O, but got Unknown try { LethalConfigManager.SetModDescription("No desc yet"); string path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "icon.png"); if (File.Exists(path)) { byte[] array = File.ReadAllBytes(path); Texture2D val = new Texture2D(2, 2); if (ImageConversion.LoadImage(val, array)) { LethalConfigManager.SetModIcon(Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f))); } } object obj = <>O.<0>__ApplyChanges; if (obj == null) { GenericButtonHandler val2 = ApplyChanges; <>O.<0>__ApplyChanges = val2; obj = (object)val2; } LethalConfigManager.AddConfigItem((BaseConfigItem)new GenericButtonConfigItem("RELOAD CONFIG", "Apply all config file changes", "Reloads the config file for Monitor Label Continued\nThis way the settings will take immediate effect.", "Apply", (GenericButtonHandler)obj)); object obj2 = <>O.<1>__RequestMigration; if (obj2 == null) { GenericButtonHandler val3 = ConfigMigration.RequestMigration; <>O.<1>__RequestMigration = val3; obj2 = (object)val3; } LethalConfigManager.AddConfigItem((BaseConfigItem)new GenericButtonConfigItem("RELOAD CONFIG", "Import settings from original mod (3s-Double click)", "Imports your settings from the original MonitorLabels mod (if found). Warning: This will overwrite your current settings! [[ require a 3s-Double click to execute ]]", "Migrate", (GenericButtonHandler)obj2)); MonitorLabelsContinued.Logger.LogInfo((object)"Successfully registered configs with LethalConfig!"); } catch (Exception ex) { MonitorLabelsContinued.Logger.LogWarning((object)("Failed to register with LethalConfig: " + ex.Message)); } } private static void ApplyChanges() { BepInExConfig.ReadConfig(); } [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)] public static void RegisterDevColor(ConfigEntry devColorConfig) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_000c: Expected O, but got Unknown try { LethalConfigManager.AddConfigItem((BaseConfigItem)new HexColorInputFieldConfigItem(devColorConfig, false)); MonitorLabelsContinued.Logger.LogInfo((object)"Registered DevRadarColor with LethalConfig!"); } catch (Exception ex) { MonitorLabelsContinued.Logger.LogWarning((object)("Failed to register DevRadarColor with LethalConfig: " + ex.Message)); } } } public static class LobbyCompatModIntegration { [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)] public static void Register(string pluginGuid, string pluginVersion) { try { PluginHelper.RegisterPlugin(pluginGuid, new Version(pluginVersion), (CompatibilityLevel)0, (VersionStrictness)0); MonitorLabelsContinued.Logger.LogInfo((object)"Successfully registered with LobbyCompatibility."); } catch (Exception ex) { MonitorLabelsContinued.Logger.LogWarning((object)("Failed to register with LobbyCompatibility: " + ex.Message)); } } } } namespace Monitor_Labels_Continued.ModCompat { internal class InitModCompat { public static void Init() { } } } namespace Monitor_Labels_Continued.BepInEx { internal class BepInExConfig { public static ConfigEntry LoggingLevel; public static ConfigEntry ForceDeadPlayerLabel; public static ConfigEntry MaximumNameLength; public static ConfigEntry ShowLabelOnTarget; public static ConfigEntry CustomDeadName; public static ConfigEntry HidePlayerLabels; public static ConfigEntry HideDeadPlayerLabels; public static ConfigEntry HideRadarBoosterLabels; public static ConfigEntry UseColorsToShowPlayerHealth; public static ConfigEntry ShowIconOnTools; public static ConfigEntry ShowLabelOnTools; public static ConfigEntry ShowBatteryChargeOnLabel; public static ConfigEntry ToolLabelFontSize; public static ConfigEntry HideToolLabelIfOnShip; public static ConfigEntry HideToolLabelIfInHand; public static ConfigEntry HideToolLabelIfPocketed; public static ConfigEntry OnlyShow1PocketedLabel; public static ConfigEntry ShowToolIfInUseAndNoOtherToolHeld; public static ConfigEntry ShowLabelOnScrap; public static ConfigEntry ScrapLabelScaleFactor; public static ConfigEntry HideScrapLabelIfOnShip; public static ConfigEntry HideScrapLabelIfCarried; public static ConfigEntry HighValueScrapThreshold; public static ConfigEntry HideScrapLabelOnNutcracker; public static ConfigEntry ShowLabelOnEnemies; public static ConfigEntry ShowLabelOnDeadEnemies; public static ConfigEntry HideLabelOnSomeEnemies; public static ConfigEntry UnknownLabel; public static ConfigEntry BaboonHawkLabel; public static ConfigEntry BlobLabel; public static ConfigEntry CentipedeLabel; public static ConfigEntry CrawlerLabel; public static ConfigEntry ManticoilLabel; public static ConfigEntry BrackenLabel; public static ConfigEntry ForestGiantLabel; public static ConfigEntry HoarderBugLabel; public static ConfigEntry JesterLabel; public static ConfigEntry MaskedLabel; public static ConfigEntry DogLabel; public static ConfigEntry NutCrackerLabel; public static ConfigEntry SporeLizardLabel; public static ConfigEntry SpiderLabel; public static ConfigEntry SandWormLabel; public static ConfigEntry CoilHeadLabel; public static ConfigEntry ButlerLabel; public static ConfigEntry RadMechLabel; public static ConfigEntry FlowerSnakeLabel; public static ConfigEntry ManeaterLabel; public static ConfigEntry BabyManeaterLabel; public static ConfigEntry ClaySurgeonLabel; public static ConfigEntry BushWolfLabel; public static ConfigEntry DeadPlayerLabelColour; public static ConfigEntry TargetPlayerLabelColour; public static ConfigEntry DefaultPlayerLabelColour; public static ConfigEntry PlayerFullHealthColour; public static ConfigEntry PlayerHalfHealthColour; public static ConfigEntry PlayerCriticalHealthColour; public static ConfigEntry TargetRadarBoosterLabelColour; public static ConfigEntry RadarBoosterLabelColour; public static ConfigEntry EnemyLabelColour; public static ConfigEntry DeadEnemyLabelColour; public static ConfigEntry ToolLabelColour; public static ConfigEntry CarriedToolLabelColour; public static ConfigEntry InShipToolLabelColour; public static ConfigEntry ScrapLabelColour; public static ConfigEntry HighValueScrapLabelColour; public static ConfigEntry CarriedScrapLabelColour; public static ConfigEntry InShipScrapLabelColour; public static ConfigEntry RadarTargetLabelOffset; public static ConfigEntry EnemyLabelOffset; public static ConfigEntry ToolLabelOffset; public static ConfigEntry ScrapLabelOffset; public static ConfigEntry RemoveDetonatedMineLabel; public static ConfigEntry PlayerLabelStringFormat; public static ConfigEntry PlayerCarriedScrapValueStringFormat; public static ConfigEntry ScrapLabelStringFormat; public static ConfigEntry ToolLabelStringFormat; public static ConfigEntry ToolBatteryStringFormat; public static ConfigFile config; internal static void Init(ConfigFile configFile) { config = configFile; } public static void ReadConfig() { //IL_06a9: Unknown result type (might be due to invalid IL or missing references) //IL_06cc: Unknown result type (might be due to invalid IL or missing references) //IL_06ef: Unknown result type (might be due to invalid IL or missing references) //IL_0712: Unknown result type (might be due to invalid IL or missing references) //IL_0750: Unknown result type (might be due to invalid IL or missing references) //IL_0793: Unknown result type (might be due to invalid IL or missing references) //IL_07c2: Unknown result type (might be due to invalid IL or missing references) //IL_07e5: Unknown result type (might be due to invalid IL or missing references) //IL_081c: Unknown result type (might be due to invalid IL or missing references) //IL_083f: Unknown result type (might be due to invalid IL or missing references) //IL_0876: Unknown result type (might be due to invalid IL or missing references) //IL_08ad: Unknown result type (might be due to invalid IL or missing references) //IL_08e4: Unknown result type (might be due to invalid IL or missing references) //IL_0907: Unknown result type (might be due to invalid IL or missing references) //IL_093e: Unknown result type (might be due to invalid IL or missing references) //IL_0961: Unknown result type (might be due to invalid IL or missing references) //IL_0984: Unknown result type (might be due to invalid IL or missing references) //IL_09a7: Unknown result type (might be due to invalid IL or missing references) //IL_09ca: Unknown result type (might be due to invalid IL or missing references) //IL_09d4: Unknown result type (might be due to invalid IL or missing references) //IL_09f7: Unknown result type (might be due to invalid IL or missing references) //IL_0a01: Unknown result type (might be due to invalid IL or missing references) //IL_0a24: Unknown result type (might be due to invalid IL or missing references) //IL_0a2e: Unknown result type (might be due to invalid IL or missing references) //IL_0a51: Unknown result type (might be due to invalid IL or missing references) //IL_0a5b: Unknown result type (might be due to invalid IL or missing references) LoggingLevel = config.Bind("0. General", "logLevel", (LogLevel)7, "What should be logged?\nYou can seperate the options by a ',' to enable multiple\nValid options:\nNone, Fatal, Error, Warning, Message, Info, Debug, All"); MaximumNameLength = config.Bind("1.1 RadarTarget/Player", "maximumNameLength", 5, "The maximum length of the name that will be shown on the terminal"); ShowLabelOnTarget = config.Bind("1.1 RadarTarget/Player", "showLabelOnTarget", true, "Should the currently targeted player also show a label"); ForceDeadPlayerLabel = config.Bind("1.1 RadarTarget/Player", "forceDeadPlayerLabel", true, "Should the label of a dead player always be visible?\nThis is to show dead labels if 'hideNormalLabels' is disabled"); CustomDeadName = config.Bind("1.1 RadarTarget/Player", "customDeadLabel", string.Empty, "A custom label to show if someone is dead, leave empty to use their name instead"); HidePlayerLabels = config.Bind("1.1 RadarTarget/Player", "hidePlayerLabels", false, "Don't use any player labels except for 'forceDeadPlayerLabel'"); HideDeadPlayerLabels = config.Bind("1.1 RadarTarget/Player", "hideDeadPlayerLabels", false, "Don't use labels for dead players"); UseColorsToShowPlayerHealth = config.Bind("1.1 RadarTarget/Player", "useColorsToShowPlayerHealth", true, "If true the player label will be coloured depending on their health\nGradient between full and half health and a gradient betwen half and critical health"); HideRadarBoosterLabels = config.Bind("1.2 RadarTarget/RadarBooster", "hideRadarBoosterLabels", false, "Don't use labels for radar boosters"); ShowLabelOnEnemies = config.Bind("2.1 Enemies", "showLabelOnEnemies", true, "Should enemies have labels?"); ShowLabelOnDeadEnemies = config.Bind("2.1 Enemies", "showLabelOnDeadEnemies", false, "Should the label stay on a dead enemy?"); HideLabelOnSomeEnemies = config.Bind("2.1 Enemies", "hideLabelOnSomeEnemies", true, "Don't show a label for the following enemies:\nManticoil\nWorm"); UnknownLabel = config.Bind("2.2 Enemy Labels", "unknownLabel", string.Empty, "The label of an unidentified enemy, leave empty to use the name"); BaboonHawkLabel = config.Bind("2.2 Enemy Labels", "baboonHawkLabel", "Hawk", "The label of the BaboonBird enemy"); BlobLabel = config.Bind("2.2 Enemy Labels", "blobLabel", "Blob", "The label of the Blob enemy"); CentipedeLabel = config.Bind("2.2 Enemy Labels", "snareFleaLabel", "Snare", "The label of the Centipede (Snare Flea) enemy"); CrawlerLabel = config.Bind("2.2 Enemy Labels", "crawlerLabel", "Half", "The label of the Crawler (Thumper) enemy"); ManticoilLabel = config.Bind("2.2 Enemy Labels", "manticoilLabel", "Bird", "The label of the Doublewing (Manticoil) enemy"); BrackenLabel = config.Bind("2.2 Enemy Labels", "brackenLabel", "Bracken", "The label of the FlowerMan (Bracken) enemy"); ForestGiantLabel = config.Bind("2.2 Enemy Labels", "forestGiantLabel", "Giant", "The label of the ForestGiant enemy"); HoarderBugLabel = config.Bind("2.2 Enemy Labels", "hoarderBugLabel", "Bug", "The label of the HoarderBug enemy"); JesterLabel = config.Bind("2.2 Enemy Labels", "jesterLabel", "Jester", "The label of the Jester enemy"); MaskedLabel = config.Bind("2.2 Enemy Labels", "maskedPlayerLabel", "X", "The label of the MaskedPlayer enemy"); DogLabel = config.Bind("2.2 Enemy Labels", "mouthDogLabel", "Dog", "The label of the MouthDog enemy"); NutCrackerLabel = config.Bind("2.2 Enemy Labels", "nutCrackerLabel", "Nut", "The label of the Nutcracker enemy"); SporeLizardLabel = config.Bind("2.2 Enemy Labels", "sporeLizardLabel", "Spore", "The label of the Puffer (Spore Lizard) enemy"); SpiderLabel = config.Bind("2.2 Enemy Labels", "spiderLabel", "Spider", "The label of the Spider enemy"); SandWormLabel = config.Bind("2.2 Enemy Labels", "sandWormLabel", string.Empty, "The label of the SandWorm enemy"); CoilHeadLabel = config.Bind("2.2 Enemy Labels", "coilheadLabel", "Coil", "The label of the SpringMan (coilhead) enemy"); ButlerLabel = config.Bind("2.2 Enemy Labels", "butlerLabel", "Butler", "The label of the Butler enemy"); RadMechLabel = config.Bind("2.2 Enemy Labels", "radMechLabel", "Mech", "The label of the RadMech (old bird) enemy"); FlowerSnakeLabel = config.Bind("2.2 Enemy Labels", "flowerSnakeLabel", "Snake", "The label of the FlowerSnake (Tulip Snake) enemy"); BushWolfLabel = config.Bind("2.2 Enemy Labels", "bushWolfLabel", "Fox", "The label of the BushWolf (Kidnapper Fox) enemy"); ManeaterLabel = config.Bind("2.2 Enemy Labels", "maneaterLabel", "Maneater", "The label of the CaveDweller (Maneater) enemy"); BabyManeaterLabel = config.Bind("2.2 Enemy Labels", "babyManeaterLabel", "Baby", "The label of the CaveDweller (Maneater) enemy when in 'baby' state"); ClaySurgeonLabel = config.Bind("2.2 Enemy Labels", "claySurgeonLabel", "Barber", "The label of the ClaySurgeon (Barber) enemy"); ShowIconOnTools = config.Bind("3.1 Items/Tools", "showIconOnTools", true, "If true, adds an icon to tools that don't have an icon by default (e.g. Keys, flashlights, shovels)"); ShowLabelOnTools = config.Bind("3.1 Items/Tools", "showLabelOnTools", true, "If true, adds a label to tools (e.g. Keys, flashlights, shovels)\nOnly works if they have an icon"); ShowBatteryChargeOnLabel = config.Bind("3.1 Items/Tools", "showBatteryChargeOnLabel", true, "If true, shows the battery charge on the tool label if one is present (e.g. Flashlights)"); ToolLabelFontSize = config.Bind("3.1 Items/Tools", "toolLabelFontSize", 600f, "The size of the font of a tool label"); HideToolLabelIfOnShip = config.Bind("3.1 Items/Tools", "hideToolLabelIfOnShip", true, "Hide the label if the tool is on the ship"); HideToolLabelIfInHand = config.Bind("3.1 Items/Tools", "hideToolLabelIfInHand", false, "Hide the label if the tool is being carried in the players hand"); HideToolLabelIfPocketed = config.Bind("3.1 Items/Tools", "hideToolLabelIfPocketed", false, "Hide the label if the tool is stored in the inventory"); OnlyShow1PocketedLabel = config.Bind("3.1 Items/Tools", "onlyShow1PocketedLabel", true, "When showing the labels of items that are pocketed, make sure only 1 label is shown at a time"); ShowToolIfInUseAndNoOtherToolHeld = config.Bind("3.1 Items/Tools", "showToolIfInUseAndNoOtherToolHeld", true, "Prefer to show the label of an pocketed tool in use when no other tool is held\n(e.g. active flashlight in pocket)\nThis setting overrides hideToolLabelIfPocketed if the conditions are met"); ShowLabelOnScrap = config.Bind("3.2 Items/Scrap", "showLabelOnScrap", true, "Should scrap also have a label?"); ScrapLabelScaleFactor = config.Bind("3.2 Items/Scrap", "scrapLabelScaleFactor", 3.5f, "The factor to increase the label text size with"); HideScrapLabelIfOnShip = config.Bind("3.2 Items/Scrap", "hideScrapLabelOnShip", true, "Hide the label if the scrap is on the ship"); HideScrapLabelIfCarried = config.Bind("3.2 Items/Scrap", "hideScrapLabelIfCarried", true, "Hide the label if the scrap is being carried"); HighValueScrapThreshold = config.Bind("3.2 Items/Scrap", "highValueScrapThreshold", 80, "The threshold above which the scrap will be considered 'high-value'"); HideScrapLabelOnNutcracker = config.Bind("3.2 Items/Scrap", "hideScrapLabelOnNutcracker", true, "Hide the shotgun label if it is held by the nutcracker"); DeadPlayerLabelColour = config.Bind("4.1 Colours/Players", "deadPlayerLabelColour", Color.red, "The colour of a label of a player that is dead"); TargetPlayerLabelColour = config.Bind("4.1 Colours/Players", "targetPlayerLabelColour", Color.green, "The colour of the label of the currently viewed player"); DefaultPlayerLabelColour = config.Bind("4.1 Colours/Players", "defaultPlayerLabelColour", Color.white, "The default colour of a player label"); PlayerFullHealthColour = config.Bind("4.1 Colours/Players", "playerFullHealthColour", Color.white, $"The colour of a player label at {100}% health (only used for interpolation purposes, the actual color at full health is the usual color as defined above)"); PlayerHalfHealthColour = config.Bind("4.1 Colours/Players", "playerHalfHealthColour", new Color(1f, 0.31f, 0.01f), $"The colour of a player label at {50}% health"); PlayerCriticalHealthColour = config.Bind("4.1 Colours/Players", "playerCriticalHealthColour", new Color(0.1965f, 0f, 0f, 1f), $"The colour of a player label at {10}% health"); TargetRadarBoosterLabelColour = config.Bind("4.2 Colours/RadarBooster", "targetRadarBoosterLabelColour", Color.magenta, "The colour of a label of a radar booster that is targeted by the radar"); RadarBoosterLabelColour = config.Bind("4.2 Colours/RadarBooster", "radarBoosterLabelColour", Color.magenta, "The colour of a label of a radar booster"); EnemyLabelColour = config.Bind("4.3 Colours/Enemies", "enemyLabelColour", new Color(1f, 0.5f, 0.2f, 1f), "The colour of a label of an enemy"); DeadEnemyLabelColour = config.Bind("4.3 Colours/Enemies", "deadEnemyLabelColour", Color.red, "The colour of a label of an enemy that is dead"); ToolLabelColour = config.Bind("4.4 Colours/Tools", "toolLabelColour", new Color(1f, 0.5f, 0.2f, 1f), "The colour of the label of tools"); CarriedToolLabelColour = config.Bind("4.4 Colours/Tools", "carriedToolLabelColour", new Color(1f, 0.5f, 0.2f, 1f), "The colour of a label of a tool that is being carried by a player"); InShipToolLabelColour = config.Bind("4.4 Colours/Tools", "inShipToolLabelColour", new Color(1f, 0.5f, 0.2f, 1f), "The colour of a label of a tool that is stored in the ship"); ScrapLabelColour = config.Bind("4.5 Colours/Scrap", "scrapLabelColour", Color.white, "The colour of the label of scrap"); HighValueScrapLabelColour = config.Bind("4.5 Colours/Scrap", "highValueScrapLabelColour", new Color(1f, 0.5f, 0.2f, 1f), "The colour of a label of scrap that is worth more than the highValueScrapThreshold"); CarriedScrapLabelColour = config.Bind("4.5 Colours/Scrap", "carriedScrapLabelColour", Color.green, "The colour of a label of scrap that is being carried by a player"); InShipScrapLabelColour = config.Bind("4.5 Colours/Scrap", "inShipScrapLabelColour", Color.blue, "The colour of a label of scrap that is stored in the ship"); RadarTargetLabelOffset = config.Bind("5.1 Label Offsets/RadarTarget", "radarTargetLabelOffset", Vector2.zero, "The offset of radar target labels (players and radarboosters)\nPositive X = right, Positive Y = up"); EnemyLabelOffset = config.Bind("5.2 Label Offsets/Enemies", "enemyLabelOffset", Vector2.down * 0.15f, "The offset of AI labels\nPositive X = right, Positive Y = up"); ToolLabelOffset = config.Bind("5.3 Label Offsets/Items", "toolLabelOffset", Vector2.up * 1.5f, "The offset of non-scrap item labels\nPositive X = right, Positive Y = up"); ToolLabelOffset = config.Bind("5.3 Label Offsets/Items", "toolLabelOffset", Vector2.up * 1.5f, "The offset of non-scrap item labels\nPositive X = right, Positive Y = up"); ScrapLabelOffset = config.Bind("5.3 Label Offsets/Items", "scrapLabelOffset", Vector2.up * 1.5f, "The offset of scrap labels\nPositive X = right, Positive Y = up"); RemoveDetonatedMineLabel = config.Bind("9. Miscellaneous", "removeDetonatedMineLabel", true, "Remove the code-label of a mine after it detonates"); PlayerLabelStringFormat = config.Bind("99. Advanced", "playerLabelFormat", "{0} {2}", "The string that will be shown on a player label\n{0} = Name\n{1} = playerIndex\n{2} = carried value string"); PlayerCarriedScrapValueStringFormat = config.Bind("99. Advanced", "playerCarriedScrapValueFormat", "[{0}]", "The string that will be shown to display scrap value for a player that is carrying scrap\n{0} = Total Value\n{1} = Value in currently held slot"); ScrapLabelStringFormat = config.Bind("99. Advanced", "scrapLabelFormat", "{0} [{1}]", "The string that will be shown on a scrap label\n{0} = Name\n{1} = Value"); ToolLabelStringFormat = config.Bind("99. Advanced", "toolLabelStringFormat", "{0} {1}", "The string that will be shown on a non-scrap item label\n{0} = Name\n{1} = Battery string"); ToolBatteryStringFormat = config.Bind("99. Advanced", "toolBatteryStringFormat", "[{0:P0}]", "The string that will be shown for the battery charge\n{0} = Battery charge"); } } internal class BepInExPatchs { public static void Init() { //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_000b: Expected O, but got Unknown Harmony val = new Harmony("LethalCompany.Lego.MonitorLabelContinued"); MonitorLabelsContinued.Logger.LogInfo((object)"Attempting to patch with Harmony!"); try { val.PatchAll(typeof(HarmonyPatches)); MonitorLabelsContinued.Logger.LogInfo((object)"Patching success!"); } catch (Exception ex) { MonitorLabelsContinued.Logger.LogInfo((object)("Failed to patch: " + ex)); } } } internal class HarmonyPatches { [HarmonyPatch(typeof(ManualCameraRenderer), "Awake")] [HarmonyPostfix] [HarmonyPriority(200)] private static void ManualCameraRendererAwakePatch(ManualCameraRenderer __instance) { MonitorLabelsContinued.Logger.LogInfo((object)"ManualCameraRenderer.Awake patch run"); NetworkManager networkManager = ((NetworkBehaviour)__instance).NetworkManager; if (!((Object)(object)networkManager == (Object)null) && networkManager.IsListening) { RadarTargetLabelManager.UpdateLabels(); if (__instance.mapCamera != null) { ((Component)__instance.mapCamera).gameObject.AddComponent(); } } } [HarmonyPatch(typeof(ManualCameraRenderer), "AddTransformAsTargetToRadar")] [HarmonyPostfix] [HarmonyPriority(200)] private static void ManualCameraRendererAddTransformAsTargetToRadarPatch() { MonitorLabelsContinued.Logger.LogInfo((object)"ManualCameraRenderer.AddTransformAsTargetToRadar patch run"); RadarTargetLabelManager.UpdateLabels(); } [HarmonyPatch(typeof(ManualCameraRenderer), "updateMapTarget")] [HarmonyPostfix] [HarmonyPriority(200)] private static void ManualCameraRendererUpdateMapTargetPatch(int setRadarTargetIndex, bool calledFromRPC = true) { if (calledFromRPC) { MonitorLabelsContinued.Logger.LogInfo((object)"ManualCameraRenderer.updateMapTarget patch run"); RadarTargetLabelManager.UpdateLabels(setRadarTargetIndex); } } [HarmonyPatch(typeof(PlayerControllerB), "SendNewPlayerValuesClientRpc")] [HarmonyPostfix] [HarmonyPriority(200)] private static void PlayerControllerBSendNewPlayerValuesClientRpcPatch(PlayerControllerB __instance) { MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.SendNewPlayerValuesClientRpc patch run")); RadarTargetLabelManager.UpdateLabels(); } [HarmonyPatch(typeof(StartOfRound), "SetShipReadyToLand")] [HarmonyPostfix] [HarmonyPriority(200)] private static void StartOfRoundSetShipReadyToLandPatch() { MonitorLabelsContinued.Logger.LogInfo((object)"StartOfRound.SetShipReadyToLand patch run"); RadarTargetLabelManager.UpdateLabels(); } [HarmonyPatch(typeof(PlayerControllerB), "DamagePlayerClientRpc")] [HarmonyPostfix] [HarmonyPriority(200)] private static void PlayerControllerBDamagePlayerClientRpcPatch(PlayerControllerB __instance) { MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.DamagePlayerClientRpc patch run")); RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform); } [HarmonyPatch(typeof(PlayerControllerB), "KillPlayerClientRpc")] [HarmonyPostfix] [HarmonyPriority(200)] private static void PlayerControllerBKillPlayerClientRpcPatch(PlayerControllerB __instance) { MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.KillPlayerClientRpc patch run")); RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform); } [HarmonyPatch(typeof(EnemyAI), "Start")] [HarmonyPostfix] [HarmonyPriority(200)] private static void EnemyAIStartPatch(EnemyAI __instance) { MonitorLabelsContinued.Logger.LogInfo((object)"EnemyAI.Start patch run"); if (BepInExConfig.ShowLabelOnEnemies.Value) { AIMapLabelManager.AddLabelToAI(__instance, ((Component)__instance).transform, checkDisabledObjectsForMapDot: false); } } [HarmonyPatch(typeof(CaveDwellerAI), "becomeAdultAnimation")] [HarmonyPostfix] [HarmonyPriority(200)] private static void becomeAdultAnimationPatch(CaveDwellerAI __instance) { MonitorLabelsContinued.Logger.LogInfo((object)"CaveDwellerAI.becomeAdultAnimation patch run"); if (BepInExConfig.ShowLabelOnEnemies.Value) { __instance.growthMeter = 1f; AIMapLabelManager.AddLabelToAI((EnemyAI)(object)__instance, __instance.adultContainer.transform, checkDisabledObjectsForMapDot: true); } } [HarmonyPatch(typeof(MaskedPlayerEnemy), "Start")] [HarmonyPostfix] [HarmonyPriority(200)] private static void MaskedPlayerEnemyStartPatch(MaskedPlayerEnemy __instance) { MonitorLabelsContinued.Logger.LogInfo((object)"MaskedPlayerEnemy.Start patch run"); if (BepInExConfig.ShowLabelOnEnemies.Value) { AIMapLabelManager.AddLabelToAI((EnemyAI)(object)__instance, ((Component)__instance).transform, checkDisabledObjectsForMapDot: false); } } [HarmonyPatch(typeof(EnemyAI), "KillEnemy")] [HarmonyPostfix] [HarmonyPriority(200)] private static void EnemyAIKillEnemyPatch(EnemyAI __instance, bool destroy = false) { MonitorLabelsContinued.Logger.LogInfo((object)"EnemyAI.KillEnemy patch run"); if (!destroy && BepInExConfig.ShowLabelOnEnemies.Value && !((Object)(object)__instance == (Object)null)) { AIMapLabelManager.UpdateAILabel(__instance); } } [HarmonyPatch(typeof(NutcrackerEnemyAI), "GrabGun")] [HarmonyPostfix] [HarmonyPriority(200)] private static void NutcrackerEnemyAIGrabGunPatch(NutcrackerEnemyAI __instance) { MonitorLabelsContinued.Logger.LogInfo((object)"NutcrackerEnemyAI.GrabGun patch run"); if (BepInExConfig.ShowLabelOnScrap.Value && !((Object)(object)__instance.gun == (Object)null)) { ObjectLabelManager.UpdateScrapLabel((GrabbableObject)(object)__instance.gun); } } [HarmonyPatch(typeof(NutcrackerEnemyAI), "DropGun")] [HarmonyPostfix] [HarmonyPriority(200)] private static void NutcrackerEnemyAIDropGunPatch(NutcrackerEnemyAI __instance) { MonitorLabelsContinued.Logger.LogInfo((object)"NutcrackerEnemyAI.DropGun patch run"); if (BepInExConfig.ShowLabelOnScrap.Value && !((Object)(object)__instance.gun == (Object)null)) { ObjectLabelManager.UpdateScrapLabel((GrabbableObject)(object)__instance.gun); } } [HarmonyPatch(typeof(GrabbableObject), "Start")] [HarmonyPostfix] [HarmonyPriority(200)] private static void GrabbableObjectStartPatch(GrabbableObject __instance) { MonitorLabelsContinued.Logger.LogInfo((object)"GrabbableObject.Start patch run"); ((Component)__instance).gameObject.AddComponent(); if (!__instance.itemProperties.isScrap) { if (BepInExConfig.ShowIconOnTools.Value && (Object)(object)__instance.radarIcon == (Object)null) { ToolIconSpawner.SpawnIcon(__instance); } if (BepInExConfig.ShowLabelOnTools.Value) { ObjectLabelManager.TryAddLabelToScrap(__instance); } } else if (BepInExConfig.ShowLabelOnScrap.Value) { ObjectLabelManager.TryAddLabelToScrap(__instance); } } [HarmonyPatch(typeof(GrabbableObject), "OnBroughtToShip")] [HarmonyPrefix] [HarmonyPriority(200)] private static bool GrabbableObjectOnBroughtToShipPatch(GrabbableObject __instance) { MonitorLabelsContinued.Logger.LogInfo((object)"GrabbableObject.OnBroughtToShip patch run"); return __instance.itemProperties.isScrap; } [HarmonyPatch(typeof(GrabbableObject), "SetScrapValue")] [HarmonyPostfix] [HarmonyPriority(200)] private static void GrabbableObjectSetScrapValuePatch(GrabbableObject __instance) { MonitorLabelsContinued.Logger.LogInfo((object)"GrabbableObject.SetScrapValue patch run"); if (BepInExConfig.ShowLabelOnScrap.Value) { PlayerControllerB playerHeldBy = __instance.playerHeldBy; if ((Object)(object)playerHeldBy != (Object)null) { RadarTargetLabelManager.UpdateLabel(((Component)playerHeldBy).transform); PlayerItemSlotsUtil.GetFirstToolAndFirstToolInUse(playerHeldBy, out var firstTool, out var firstToolInUse); ObjectLabelManager.UpdateItemSlotLabel(__instance, firstTool, firstToolInUse); } else { ObjectLabelManager.UpdateScrapLabel(__instance); } } } [HarmonyPatch(typeof(PlayerControllerB), "SwitchToItemSlot")] [HarmonyPostfix] [HarmonyPriority(200)] private static void PlayerControllerBSwitchToItemSlotPatch(PlayerControllerB __instance) { MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.SwitchToItemSlot patch run")); PlayerItemSlotsUtil.UpdateLabelsOfItemSlots(__instance); } [HarmonyPatch(typeof(GrabbableObject), "UseItemOnClient")] [HarmonyPostfix] [HarmonyPriority(200)] private static void GrabbableObjectUseItemOnClientPatch(GrabbableObject __instance) { MonitorLabelsContinued.Logger.LogInfo((object)"GrabbableObject.UseItemOnClient patch run"); PlayerControllerB playerHeldBy = __instance.playerHeldBy; if (playerHeldBy != null) { PlayerItemSlotsUtil.UpdateLabelsOfItemSlots(playerHeldBy); } else if (!__instance.itemProperties.isScrap && BepInExConfig.ShowLabelOnTools.Value) { ObjectLabelManager.UpdateScrapLabel(__instance); } } [HarmonyPatch(typeof(PlayerControllerB), "SetItemInElevator")] [HarmonyPostfix] [HarmonyPriority(200)] private static void PlayerControllerBSetItemInElevatorPatch(PlayerControllerB __instance, GrabbableObject gObject) { MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.SetItemInElevator patch run")); RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform); if ((Object)(object)gObject == (Object)null) { return; } if (gObject.itemProperties.isScrap) { if (!BepInExConfig.ShowLabelOnScrap.Value) { return; } } else if (!BepInExConfig.ShowLabelOnTools.Value) { return; } ObjectLabelManager.UpdateScrapLabel(gObject); } [HarmonyPatch(typeof(GrabbableObject), "DiscardItemOnClient")] [HarmonyPostfix] [HarmonyPriority(200)] private static void GrabbableObjectDiscardItemOnClientPatch(GrabbableObject __instance) { MonitorLabelsContinued.Logger.LogInfo((object)"GrabbableObject.DiscardItemOnClient patch run"); ObjectLabelManager.UpdateScrapLabel(__instance); } [HarmonyPatch(typeof(PlayerControllerB), "PlaceObjectClientRpc")] [HarmonyPostfix] [HarmonyPriority(200)] private static void PlayerControllerBPlaceObjectClientRpcPatch(PlayerControllerB __instance, ref NetworkObjectReference grabbedObject) { MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.PlaceObjectClientRpc patch run")); RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform); PlayerItemSlotsUtil.UpdateLabelsOfItemSlots(__instance); NetworkObject val = default(NetworkObject); if (((NetworkObjectReference)(ref grabbedObject)).TryGet(ref val, (NetworkManager)null)) { ObjectLabelManager.UpdateScrapLabel(((Component)val).GetComponent()); } } [HarmonyPatch(typeof(PlayerControllerB), "ThrowObjectClientRpc")] [HarmonyPostfix] [HarmonyPriority(200)] private static void PlayerControllerBThrowObjectClientRpcPatch(PlayerControllerB __instance, ref NetworkObjectReference grabbedObject) { MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.ThrowObjectClientRpc patch run")); RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform); PlayerItemSlotsUtil.UpdateLabelsOfItemSlots(__instance); NetworkObject val = default(NetworkObject); if (((NetworkObjectReference)(ref grabbedObject)).TryGet(ref val, (NetworkManager)null)) { ObjectLabelManager.UpdateScrapLabel(((Component)val).GetComponent()); } } [HarmonyPatch(typeof(PlayerControllerB), "GrabObjectClientRpc")] [HarmonyPostfix] [HarmonyPriority(200)] private static void PlayerControllerBGrabObjectClientRpcPatch(PlayerControllerB __instance, NetworkObjectReference grabbedObject) { //IL_002a: Unknown result type (might be due to invalid IL or missing references) MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.GrabObjectClientRpc patch run")); RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform); GrabbableObject componentInChildren = ((Component)NetworkObjectReference.op_Implicit(grabbedObject)).GetComponentInChildren(); if ((Object)(object)componentInChildren == (Object)null) { return; } if (componentInChildren.itemProperties.isScrap) { if (BepInExConfig.ShowLabelOnScrap.Value) { ObjectLabelManager.UpdateScrapLabel(componentInChildren); } } else if (BepInExConfig.ShowLabelOnTools.Value) { PlayerItemSlotsUtil.UpdateLabelsOfItemSlots(__instance); } } [HarmonyPatch(typeof(Landmine), "Detonate")] [HarmonyPostfix] [HarmonyPriority(200)] private static void LandMineDetonatePatch(Landmine __instance) { MonitorLabelsContinued.Logger.LogInfo((object)"Landmine.Detonate patch run"); if (BepInExConfig.RemoveDetonatedMineLabel.Value) { TerminalAccessibleObject component = ((Component)__instance).GetComponent(); if (component != null && component.mapRadarText != null) { ((Component)component.mapRadarText).gameObject.SetActive(false); } } } [HarmonyPatch(typeof(RoundManager), "FinishGeneratingLevel")] [HarmonyPostfix] [HarmonyPriority(200)] private static void RoundManagerFinishGeneratingLevelPatch() { MonitorLabelsContinued.Logger.LogInfo((object)"RoundManager.FinishGeneratingLevel patch run"); UpdateAllGroundItems(); } [HarmonyPatch(typeof(StartOfRound), "LoadShipGrabbableItems")] [HarmonyPostfix] [HarmonyPriority(200)] private static void StartOfRoundLoadShipGrabbableItemsPatch() { MonitorLabelsContinued.Logger.LogInfo((object)"StartOfRound.LoadShipGrabbableItems patch run"); UpdateAllGroundItems(); } private static void UpdateAllGroundItems() { GrabbableObject[] array = Object.FindObjectsOfType(); foreach (GrabbableObject val in array) { if ((Object)(object)val != (Object)null && !val.isHeld) { ObjectLabelManager.UpdateScrapLabel(val); } } } [HarmonyPatch(typeof(StartOfRound), "Start")] [HarmonyPostfix] [HarmonyPriority(200)] private static void StartOfRoundStartPatch(StartOfRound __instance) { //IL_0023: Unknown result type (might be due to invalid IL or missing references) //IL_009e: Unknown result type (might be due to invalid IL or missing references) //IL_00a3: Unknown result type (might be due to invalid IL or missing references) if ((Object)(object)GameNetworkManager.Instance == (Object)null || !GameNetworkManager.Instance.currentLobby.HasValue) { return; } try { if (SteamId.op_Implicit(SteamClient.SteamId) == 76561198368204860L) { ConfigEntry val = BepInExConfig.config.Bind("(Dev) Easter Eggs", "DevRadarColor", Colors.ContinuedDevColorHex, "Your color shown on the radar map."); if (Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig")) { LethalConfigIntegration.RegisterDevColor(val); } string text = val.Value; if (!text.StartsWith("#")) { text = "#" + text; } Lobby value = GameNetworkManager.Instance.currentLobby.Value; ((Lobby)(ref value)).SetMemberData("MonitorLabelsContinued_CustomPlayerLabelColor", text); MonitorLabelsContinued.Logger.LogInfo((object)("Developer detected! Broadcasted custom radar color (" + text + ") to Steam Lobby!")); } } catch (Exception ex) { MonitorLabelsContinued.Logger.LogInfo((object)("Failed to broadcast custom lobby color: " + ex)); } } } internal class InitBepInEx { public static void Init(ConfigFile config) { MonitorLabelsContinued.Logger.LogInfo((object)"Init of config"); BepInExConfig.Init(config); MonitorLabelsContinued.Logger.LogInfo((object)"Read of config"); BepInExConfig.ReadConfig(); BepInExPatchs.Init(); } } } namespace System.Runtime.CompilerServices { [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] internal sealed class IgnoresAccessChecksToAttribute : Attribute { public IgnoresAccessChecksToAttribute(string assemblyName) { } } }