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 Microsoft.CodeAnalysis;
using MonitorLabels.BaseClasses;
using MonitorLabels.Components;
using MonitorLabels.Components.Tools;
using MonitorLabels.Constants;
using MonitorLabels.Dependencies.LethalConfig;
using MonitorLabels.ExtensionMethods;
using MonitorLabels.Structs;
using MonitorLabels.Utils;
using MonitorLabels.Utils.ModUtils;
using MonitorLabels.VanillaImprovements;
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("DannyVD")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Adds a label to the icons on the monitor for players, radar boosters, enemies and scrap")]
[assembly: AssemblyFileVersion("2.1.1.0")]
[assembly: AssemblyInformationalVersion("2.1.1+c2e6ee5e9976e7b2ce3a16204535a8e2fcaf33de")]
[assembly: AssemblyProduct("MonitorLabels")]
[assembly: AssemblyTitle("MonitorLabels")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.1.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.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<Type, CustomLabelData> CustomAINames = new Dictionary<Type, CustomLabelData>();
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_0086: 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_003c: 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_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: 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_0071: 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)
{
LoggerUtil.LogWarning("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, ConfigUtil.EnemyLabelOffset.Value);
((Graphic)obj).color = ConfigUtil.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 (!ConfigUtil.ShowLabelOnDeadEnemies.Value)
{
Object.Destroy((Object)(object)((Component)label).gameObject);
}
else
{
((Graphic)label).color = ConfigUtil.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 ConfigUtil.ClaySurgeonLabel.Value;
}
return GetUnknownAILabel(enemyAI, out showLabel);
}
if (!ManeaterUtil.HasTransformed(val))
{
return ConfigUtil.BabyManeaterLabel.Value;
}
return ConfigUtil.ManeaterLabel.Value;
}
return ConfigUtil.BushWolfLabel.Value;
}
if (ConfigUtil.HideLabelOnSomeEnemies.Value)
{
showLabel = false;
}
return ConfigUtil.FlowerSnakeLabel.Value;
}
return ConfigUtil.RadMechLabel.Value;
}
return ConfigUtil.ButlerLabel.Value;
}
return "Obunga";
}
return ConfigUtil.CoilHeadLabel.Value;
}
if (ConfigUtil.HideLabelOnSomeEnemies.Value)
{
showLabel = false;
}
return ConfigUtil.SandWormLabel.Value;
}
return ConfigUtil.SpiderLabel.Value;
}
return ConfigUtil.SporeLizardLabel.Value;
}
return ConfigUtil.NutCrackerLabel.Value;
}
return ConfigUtil.DogLabel.Value;
}
return ConfigUtil.MaskedLabel.Value;
}
return "Lasso";
}
return ConfigUtil.JesterLabel.Value;
}
return ConfigUtil.HoarderBugLabel.Value;
}
return ConfigUtil.ForestGiantLabel.Value;
}
return ConfigUtil.BrackenLabel.Value;
}
showLabel = false;
return "Girl";
}
if (ConfigUtil.HideLabelOnSomeEnemies.Value)
{
showLabel = false;
}
return ConfigUtil.ManticoilLabel.Value;
}
showLabel = false;
return "Bees";
}
return ConfigUtil.CrawlerLabel.Value;
}
return ConfigUtil.CentipedeLabel.Value;
}
return ConfigUtil.BlobLabel.Value;
}
return ConfigUtil.BaboonHawkLabel.Value;
}
private static string GetUnknownAILabel(EnemyAI enemyAISubclassInstance, out bool showLabel)
{
foreach (KeyValuePair<Type, CustomLabelData> customAIName in CustomAINames)
{
if (customAIName.Key.IsInstanceOfType(enemyAISubclassInstance))
{
showLabel = customAIName.Value.ShowLabel;
return customAIName.Value.Label;
}
}
showLabel = true;
string value = ConfigUtil.UnknownLabel.Value;
if (!value.Equals(string.Empty))
{
return value;
}
return MapLabelUtil.RemoveCloneFromString(((Object)((Component)enemyAISubclassInstance).gameObject).name).InsertSpaceBeforeCapitals();
}
}
[BepInPlugin("DannyVD.mods.LethalCompany.MonitorLabels", "MonitorLabels", "2.1.1")]
[BepInProcess("Lethal Company.exe")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class MonitorLabelsPlugin : BaseUnityPlugin
{
public const string GUID = "DannyVD.mods.LethalCompany.MonitorLabels";
public const string PLUGIN_NAME = "MonitorLabels";
public const string PLUGIN_VERSION = "2.1.1";
public const string DEPENDENCY_STRING = "DannyVD-MonitorLabels-2.1.1";
private void Awake()
{
ConfigUtil.Initialize(((BaseUnityPlugin)this).Config);
ConfigUtil.ReadConfig();
LoggerUtil.Initialize(ConfigUtil.LoggingLevel, ((BaseUnityPlugin)this).Logger);
LoggerUtil.Log((LogLevel)16, "Plugin DannyVD-MonitorLabels-2.1.1 is loaded!");
PatchUtil.PatchFunctions();
DependencyUtils.CheckDependencies();
}
}
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)
{
return;
}
ContinuouslyUpdateToolLabel component = ((Component)item).GetComponent<ContinuouslyUpdateToolLabel>();
if (!((Object)(object)component != (Object)null) || !component.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 ? ConfigUtil.ScrapLabelOffset.Value : ConfigUtil.ToolLabelOffset.Value, continuouslyUpdateRotationAndOffset: false);
if (isScrap)
{
val.fontSize *= ConfigUtil.ScrapLabelScaleFactor.Value;
}
else
{
val.fontSize = ConfigUtil.ToolLabelFontSize.Value;
}
SetScrapLabel(item, val);
if (item.itemProperties.requiresBattery && ConfigUtil.ShowBatteryChargeOnLabel.Value)
{
((Component)item).gameObject.AddComponent<ContinuouslyUpdateToolLabel>().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_0249: Unknown result type (might be due to invalid IL or missing references)
//IL_024e: Unknown result type (might be due to invalid IL or missing references)
//IL_0224: Unknown result type (might be due to invalid IL or missing references)
//IL_0229: Unknown result type (might be due to invalid IL or missing references)
//IL_0202: Unknown result type (might be due to invalid IL or missing references)
//IL_0207: Unknown result type (might be due to invalid IL or missing references)
//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
//IL_01b2: 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_0274: Unknown result type (might be due to invalid IL or missing references)
//IL_0268: Unknown result type (might be due to invalid IL or missing references)
//IL_0279: 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 = ConfigUtil.CarriedToolLabelColour.Value;
GrabbableObject currentlyHeldObjectServer = item.playerHeldBy.currentlyHeldObjectServer;
bool flag2 = (Object)(object)currentlyHeldObjectServer != (Object)null && !currentlyHeldObjectServer.itemProperties.isScrap;
if (item.isPocketed && ConfigUtil.HideToolLabelIfPocketed.Value)
{
if (!item.isBeingUsed || !ConfigUtil.ShowToolIfInUseAndNoOtherToolHeld.Value || flag2)
{
return string.Empty;
}
if (ConfigUtil.OnlyShow1PocketedLabel.Value)
{
GrabbableObject val = ((IEnumerable<GrabbableObject>)item.playerHeldBy.ItemSlots).FirstOrDefault((Func<GrabbableObject, bool>)((GrabbableObject grabbableObject) => (Object)(object)grabbableObject != (Object)null && grabbableObject.isBeingUsed));
if ((Object)(object)item != (Object)(object)val)
{
return string.Empty;
}
}
}
else if (item.isPocketed && ConfigUtil.OnlyShow1PocketedLabel.Value)
{
if (flag2 && !ConfigUtil.HideToolLabelIfInHand.Value)
{
return string.Empty;
}
if (ConfigUtil.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 && ConfigUtil.HideToolLabelIfInHand.Value)
{
return string.Empty;
}
}
else if (flag)
{
labelColour = ConfigUtil.CarriedToolLabelColour.Value;
if (ConfigUtil.HideToolLabelIfInHand.Value)
{
return string.Empty;
}
}
else
{
labelColour = ConfigUtil.CarriedScrapLabelColour.Value;
if (ConfigUtil.HideScrapLabelIfCarried.Value)
{
return string.Empty;
}
}
}
else if (item.isInShipRoom)
{
if (flag)
{
labelColour = ConfigUtil.InShipToolLabelColour.Value;
if (ConfigUtil.HideToolLabelIfOnShip.Value)
{
return string.Empty;
}
}
else
{
labelColour = ConfigUtil.InShipScrapLabelColour.Value;
if (ConfigUtil.HideScrapLabelIfOnShip.Value)
{
return string.Empty;
}
}
}
else if (flag)
{
labelColour = ConfigUtil.ToolLabelColour.Value;
}
else
{
labelColour = ((scrapValue >= ConfigUtil.HighValueScrapThreshold.Value) ? ConfigUtil.HighValueScrapLabelColour.Value : ConfigUtil.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 (ConfigUtil.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 && ConfigUtil.ShowBatteryChargeOnLabel.Value && item.insertedBattery != null)
{
float num = (item.insertedBattery.empty ? 0f : item.insertedBattery.charge);
arg = string.Format(ConfigUtil.ToolBatteryStringFormat.Value, num);
}
return string.Format(ConfigUtil.ToolLabelStringFormat.Value, scrapName, arg);
}
return string.Format(ConfigUtil.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<ScanNodeProperties>();
if (Object.op_Implicit((Object)(object)componentInChildren))
{
return componentInChildren.headerText;
}
return MapLabelUtil.RemoveCloneFromString(((Object)((Component)item).gameObject).name).InsertSpaceBeforeCapitals();
}
}
internal static class Patches
{
[HarmonyPatch(typeof(ManualCameraRenderer), "Awake")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void ManualCameraRendererAwakePatch(ManualCameraRenderer __instance)
{
LoggerUtil.LogDebug("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<MapCameraRotationObserver>();
}
}
}
[HarmonyPatch(typeof(ManualCameraRenderer), "AddTransformAsTargetToRadar")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void ManualCameraRendererAddTransformAsTargetToRadarPatch()
{
LoggerUtil.LogDebug("ManualCameraRenderer.AddTransformAsTargetToRadar patch run");
RadarTargetLabelManager.UpdateLabels();
}
[HarmonyPatch(typeof(ManualCameraRenderer), "updateMapTarget")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void ManualCameraRendererUpdateMapTargetPatch(int setRadarTargetIndex, bool calledFromRPC = true)
{
if (calledFromRPC)
{
LoggerUtil.LogDebug("ManualCameraRenderer.updateMapTarget patch run");
RadarTargetLabelManager.UpdateLabels(setRadarTargetIndex);
}
}
[HarmonyPatch(typeof(PlayerControllerB), "SendNewPlayerValuesClientRpc")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void PlayerControllerBSendNewPlayerValuesClientRpcPatch(PlayerControllerB __instance)
{
LoggerUtil.LogDebug("[" + __instance.playerUsername + "] PlayerControllerB.SendNewPlayerValuesClientRpc patch run");
RadarTargetLabelManager.UpdateLabels();
}
[HarmonyPatch(typeof(StartOfRound), "SetShipReadyToLand")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void StartOfRoundSetShipReadyToLandPatch()
{
LoggerUtil.LogDebug("StartOfRound.SetShipReadyToLand patch run");
RadarTargetLabelManager.UpdateLabels();
}
[HarmonyPatch(typeof(PlayerControllerB), "DamagePlayerClientRpc")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void PlayerControllerBDamagePlayerClientRpcPatch(PlayerControllerB __instance)
{
LoggerUtil.LogDebug("[" + __instance.playerUsername + "] PlayerControllerB.DamagePlayerClientRpc patch run");
RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform);
}
[HarmonyPatch(typeof(PlayerControllerB), "KillPlayerClientRpc")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void PlayerControllerBKillPlayerClientRpcPatch(PlayerControllerB __instance)
{
LoggerUtil.LogDebug("[" + __instance.playerUsername + "] PlayerControllerB.KillPlayerClientRpc patch run");
RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform);
}
[HarmonyPatch(typeof(EnemyAI), "Start")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void EnemyAIStartPatch(EnemyAI __instance)
{
LoggerUtil.LogDebug("EnemyAI.Start patch run");
if (ConfigUtil.ShowLabelOnEnemies.Value)
{
AIMapLabelManager.AddLabelToAI(__instance, ((Component)__instance).transform, checkDisabledObjectsForMapDot: false);
}
}
[HarmonyPatch(typeof(CaveDwellerAI), "becomeAdultAnimation")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void becomeAdultAnimationPatch(CaveDwellerAI __instance)
{
LoggerUtil.LogDebug("CaveDwellerAI.becomeAdultAnimation patch run");
if (ConfigUtil.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)
{
LoggerUtil.LogDebug("MaskedPlayerEnemy.Start patch run");
if (ConfigUtil.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)
{
LoggerUtil.LogDebug("EnemyAI.KillEnemy patch run");
if (!destroy && ConfigUtil.ShowLabelOnEnemies.Value && !((Object)(object)__instance == (Object)null))
{
AIMapLabelManager.UpdateAILabel(__instance);
}
}
[HarmonyPatch(typeof(NutcrackerEnemyAI), "GrabGun")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void NutcrackerEnemyAIGrabGunPatch(NutcrackerEnemyAI __instance)
{
LoggerUtil.LogDebug("NutcrackerEnemyAI.GrabGun patch run");
if (ConfigUtil.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)
{
LoggerUtil.LogDebug("NutcrackerEnemyAI.DropGun patch run");
if (ConfigUtil.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)
{
LoggerUtil.LogDebug("GrabbableObject.Start patch run");
((Component)__instance).gameObject.AddComponent<DestroyRadarIconOnDestroy>();
if (!__instance.itemProperties.isScrap)
{
if (ConfigUtil.ShowIconOnTools.Value && (Object)(object)__instance.radarIcon == (Object)null)
{
ToolIconSpawner.SpawnIcon(__instance);
}
if (ConfigUtil.ShowLabelOnTools.Value)
{
ObjectLabelManager.TryAddLabelToScrap(__instance);
}
}
else if (ConfigUtil.ShowLabelOnScrap.Value)
{
ObjectLabelManager.TryAddLabelToScrap(__instance);
}
}
[HarmonyPatch(typeof(GrabbableObject), "OnBroughtToShip")]
[HarmonyPrefix]
[HarmonyPriority(200)]
private static bool GrabbableObjectOnBroughtToShipPatch(GrabbableObject __instance)
{
LoggerUtil.LogDebug("GrabbableObject.OnBroughtToShip patch run");
return __instance.itemProperties.isScrap;
}
[HarmonyPatch(typeof(GrabbableObject), "SetScrapValue")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void GrabbableObjectSetScrapValuePatch(GrabbableObject __instance)
{
LoggerUtil.LogDebug("GrabbableObject.SetScrapValue patch run");
if (ConfigUtil.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)
{
LoggerUtil.LogDebug("[" + __instance.playerUsername + "] PlayerControllerB.SwitchToItemSlot patch run");
PlayerItemSlotsUtil.UpdateLabelsOfItemSlots(__instance);
}
[HarmonyPatch(typeof(GrabbableObject), "UseItemOnClient")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void GrabbableObjectUseItemOnClientPatch(GrabbableObject __instance)
{
LoggerUtil.LogDebug("GrabbableObject.UseItemOnClient patch run");
PlayerControllerB playerHeldBy = __instance.playerHeldBy;
if (playerHeldBy != null)
{
PlayerItemSlotsUtil.UpdateLabelsOfItemSlots(playerHeldBy);
}
else if (!__instance.itemProperties.isScrap && ConfigUtil.ShowLabelOnTools.Value)
{
ObjectLabelManager.UpdateScrapLabel(__instance);
}
}
[HarmonyPatch(typeof(PlayerControllerB), "SetItemInElevator")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void PlayerControllerBSetItemInElevatorPatch(PlayerControllerB __instance, GrabbableObject gObject)
{
LoggerUtil.LogDebug("[" + __instance.playerUsername + "] PlayerControllerB.SetItemInElevator patch run");
RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform);
if ((Object)(object)gObject == (Object)null)
{
return;
}
if (gObject.itemProperties.isScrap)
{
if (!ConfigUtil.ShowLabelOnScrap.Value)
{
return;
}
}
else if (!ConfigUtil.ShowLabelOnTools.Value)
{
return;
}
ObjectLabelManager.UpdateScrapLabel(gObject);
}
[HarmonyPatch(typeof(GrabbableObject), "DiscardItemOnClient")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void GrabbableObjectDiscardItemOnClientPatch(GrabbableObject __instance)
{
LoggerUtil.LogDebug("GrabbableObject.DiscardItemOnClient patch run");
ObjectLabelManager.UpdateScrapLabel(__instance);
}
[HarmonyPatch(typeof(PlayerControllerB), "PlaceObjectClientRpc")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void PlayerControllerBPlaceObjectClientRpcPatch(PlayerControllerB __instance, ref NetworkObjectReference grabbedObject)
{
LoggerUtil.LogDebug("[" + __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<GrabbableObject>());
}
}
[HarmonyPatch(typeof(PlayerControllerB), "ThrowObjectClientRpc")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void PlayerControllerBThrowObjectClientRpcPatch(PlayerControllerB __instance, ref NetworkObjectReference grabbedObject)
{
LoggerUtil.LogDebug("[" + __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<GrabbableObject>());
}
}
[HarmonyPatch(typeof(PlayerControllerB), "GrabObjectClientRpc")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void PlayerControllerBGrabObjectClientRpcPatch(PlayerControllerB __instance, NetworkObjectReference grabbedObject)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
LoggerUtil.LogDebug("[" + __instance.playerUsername + "] PlayerControllerB.GrabObjectClientRpc patch run");
RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform);
GrabbableObject componentInChildren = ((Component)NetworkObjectReference.op_Implicit(grabbedObject)).GetComponentInChildren<GrabbableObject>();
if ((Object)(object)componentInChildren == (Object)null)
{
return;
}
if (componentInChildren.itemProperties.isScrap)
{
if (ConfigUtil.ShowLabelOnScrap.Value)
{
ObjectLabelManager.UpdateScrapLabel(componentInChildren);
}
}
else if (ConfigUtil.ShowLabelOnTools.Value)
{
PlayerItemSlotsUtil.UpdateLabelsOfItemSlots(__instance);
}
}
[HarmonyPatch(typeof(Landmine), "Detonate")]
[HarmonyPostfix]
[HarmonyPriority(200)]
private static void LandMineDetonatePatch(Landmine __instance)
{
LoggerUtil.LogDebug("Landmine.Detonate patch run");
if (ConfigUtil.RemoveDetonatedMineLabel.Value)
{
TerminalAccessibleObject component = ((Component)__instance).GetComponent<TerminalAccessibleObject>();
if (component != null && component.mapRadarText != null)
{
((Component)component.mapRadarText).gameObject.SetActive(false);
}
}
}
}
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)
{
LoggerUtil.LogWarning("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_0109: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
PlayerControllerB component = ((Component)transformAndName.transform).gameObject.GetComponent<PlayerControllerB>();
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)
{
LoggerUtil.LogError("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)
{
LoggerUtil.LogError("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, ConfigUtil.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_00ea: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: 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_0117: Unknown result type (might be due to invalid IL or missing references)
//IL_011c: 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)
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_0148: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
if (isDead)
{
labelColour = ConfigUtil.DeadPlayerLabelColour.Value;
if (ConfigUtil.ForceDeadPlayerLabel.Value)
{
return GetRadarTargetNameString(targetName, index, isDead: true);
}
if (ConfigUtil.HideDeadPlayerLabels.Value || ConfigUtil.HidePlayerLabels.Value)
{
return string.Empty;
}
}
else
{
if (!isRadarBooster && ConfigUtil.HidePlayerLabels.Value)
{
labelColour = Color.white;
return string.Empty;
}
if (isTarget)
{
if (isRadarBooster)
{
labelColour = ConfigUtil.TargetRadarBoosterLabelColour.Value;
}
else if (ConfigUtil.UseColorsToShowPlayerHealth.Value)
{
labelColour = ColorCalculator.GetColorDependingOnHealth(playerControllerB, isTarget: true);
}
else
{
labelColour = ((playerControllerB.playerSteamId == 76561198166372065L) ? Colors.DevColor : ConfigUtil.TargetPlayerLabelColour.Value);
}
if (!ConfigUtil.ShowLabelOnTarget.Value)
{
return string.Empty;
}
}
else if (isRadarBooster)
{
labelColour = ConfigUtil.RadarBoosterLabelColour.Value;
if (ConfigUtil.HideRadarBoosterLabels.Value)
{
return string.Empty;
}
}
else if (ConfigUtil.UseColorsToShowPlayerHealth.Value)
{
labelColour = ColorCalculator.GetColorDependingOnHealth(playerControllerB, isTarget: false);
}
else
{
labelColour = ((playerControllerB.playerSteamId == 76561198166372065L) ? Colors.DevColor : ConfigUtil.DefaultPlayerLabelColour.Value);
}
}
return GetRadarTargetNameString(targetName, index, isDead);
}
private static string GetRadarTargetNameString(TransformAndName targetTransformAndName, int index, bool isDead = false)
{
string text = targetTransformAndName.name;
if (isDead)
{
string value = ConfigUtil.CustomDeadName.Value;
if (value != string.Empty)
{
text = value;
}
}
text = text[..Mathf.Min(text.Length, ConfigUtil.MaximumNameLength.Value)];
string arg = string.Empty;
if (!targetTransformAndName.isNonPlayer && !isDead)
{
int currentSlotValue;
int totalValueCarrying = ScrapUtil.GetTotalValueCarrying(((Component)targetTransformAndName.transform).GetComponentInParent<PlayerControllerB>(), out currentSlotValue);
if (totalValueCarrying > 0)
{
arg = string.Format(ConfigUtil.PlayerCarriedScrapValueStringFormat.Value, totalValueCarrying, currentSlotValue);
}
}
return string.Format(ConfigUtil.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;
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "MonitorLabels";
public const string PLUGIN_NAME = "MonitorLabels";
public const string PLUGIN_VERSION = "2.1.1";
}
}
namespace MonitorLabels.VanillaImprovements
{
public class DestroyRadarIconOnDestroy : BetterMonoBehaviour
{
private GrabbableObject grabbableObject;
private void Awake()
{
grabbableObject = ((Component)this).GetComponent<GrabbableObject>();
}
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.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_00a7: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: 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_005a: 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)
Color value = ConfigUtil.PlayerFullHealthColour.Value;
Color value2 = ConfigUtil.PlayerHalfHealthColour.Value;
Color value3 = ConfigUtil.PlayerCriticalHealthColour.Value;
if (playerController == null)
{
return value;
}
if (playerController.health == 100)
{
if (playerController.playerSteamId == 76561198166372065L)
{
return Colors.DevColor;
}
if (!isTarget)
{
return ConfigUtil.DefaultPlayerLabelColour.Value;
}
return ConfigUtil.TargetPlayerLabelColour.Value;
}
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 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<RotateWithMapCameraContinuously>();
labelOffsetManager = val.AddComponent<LabelOffsetManagerContinuously>();
}
else
{
val.AddComponent<RotateWithMapCamera>();
labelOffsetManager = val.AddComponent<LabelOffsetManagerEventHandler>();
}
labelOffsetManager.Offset = labelOffset;
TextMeshPro obj = val.AddComponent<TextMeshPro>();
((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<Transform> queue = new Queue<Transform>();
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<TMP_Text>() : 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;
break;
}
}
}
}
public static void UpdateLabelsOfItemSlots(PlayerControllerB player)
{
if (!ConfigUtil.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);
}
}
}
}
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;
}
}
internal static class ScaleUtils
{
public static Vector3 GetScaleToNonSkewedParent(Vector3 parentScale, Vector3 scale)
{
//IL_0008: 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_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: 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_007e: Unknown result type (might be due to invalid IL or missing references)
float desiredParentScale = Mathf.Max(new float[3] { parentScale.x, parentScale.y, parentScale.z });
scale.x *= GetScaleFactor(parentScale.x, desiredParentScale, scale.x);
scale.y *= GetScaleFactor(parentScale.y, desiredParentScale, scale.y);
scale.z *= GetScaleFactor(parentScale.z, desiredParentScale, scale.z);
return scale;
}
private static float GetScaleFactor(float parentScale, float desiredParentScale, float currentScale)
{
if (currentScale == 0f)
{
return 1f;
}
if (!Mathf.Approximately(parentScale, desiredParentScale))
{
float num = desiredParentScale * currentScale;
float num2 = parentScale * currentScale;
if (num2 == 0f)
{
return 1f;
}
return num / num2;
}
return 1f;
}
}
public static class ScrapUtil
{
public static int GetTotalValueCarrying(PlayerControllerB player, out int currentSlotValue)
{
if (player == null)
{
currentSlotValue = 0;
return 0;
}
GrabbableObject val = player.ItemSlots[player.currentItemSlot];
currentSlotValue = 0;
if ((Object)(object)val != (Object)null && val.itemProperties.isScrap)
{
currentSlotValue = val.scrapValue;
}
return player.ItemSlots.Sum((GrabbableObject item) => (!((Object)(object)item == (Object)null) && item.itemProperties.isScrap) ? item.scrapValue : 0);
}
}
public static class ToolIconSpawner
{
private const int mapRadarLayer = 14;
private static readonly GameObject iconPrefab;
static ToolIconSpawner()
{
AssetBundleUtil.TryLoadAsset<GameObject>("terminalmarker.lem", "Assets/Mods/TerminalMarker/ItemMarker.prefab", out iconPrefab);
AssetBundleUtil.TryLoadAsset<Material>("terminalmarker.lem", "Assets/Mods/TerminalMarker/MarkerMaterial.mat", out Material asset);
iconPrefab.GetComponent<Renderer>().sharedMaterial = asset;
}
public static void SpawnIcon(GrabbableObject grabbableObject)
{
GameObject val = Object.Instantiate<GameObject>(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<string, AssetBundle> loadedAssetBundles;
static AssetBundleUtil()
{
loadedAssetBundles = new Dictionary<string, AssetBundle>();
assemblyDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
}
public static bool TryLoadAsset<TAssetType>(string bundleName, string assetPath, out TAssetType asset) where TAssetType : Object
{
if (!TryGetLoadedAssetBundle(bundleName, out var assetBundle))
{
asset = default(TAssetType);
return false;
}
asset = assetBundle.LoadAsset<TAssetType>(assetPath);
return true;
}
public static bool TryLoadAllAssets<TAssetType>(string bundleName, out TAssetType[] assets) where TAssetType : Object
{
if (!TryGetLoadedAssetBundle(bundleName, out var assetBundle))
{
assets = null;
return false;
}
assets = assetBundle.LoadAllAssets<TAssetType>();
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);
}
}
public static class ConfigUtil
{
public static ConfigEntry<LogLevel> LoggingLevel;
public static ConfigEntry<bool> ForceDeadPlayerLabel;
public static ConfigEntry<int> MaximumNameLength;
public static ConfigEntry<bool> ShowLabelOnTarget;
public static ConfigEntry<string> CustomDeadName;
public static ConfigEntry<bool> HidePlayerLabels;
public static ConfigEntry<bool> HideDeadPlayerLabels;
public static ConfigEntry<bool> HideRadarBoosterLabels;
public static ConfigEntry<bool> UseColorsToShowPlayerHealth;
public static ConfigEntry<bool> ShowIconOnTools;
public static ConfigEntry<bool> ShowLabelOnTools;
public static ConfigEntry<bool> ShowBatteryChargeOnLabel;
public static ConfigEntry<float> ToolLabelFontSize;
public static ConfigEntry<bool> HideToolLabelIfOnShip;
public static ConfigEntry<bool> HideToolLabelIfInHand;
public static ConfigEntry<bool> HideToolLabelIfPocketed;
public static ConfigEntry<bool> OnlyShow1PocketedLabel;
public static ConfigEntry<bool> ShowToolIfInUseAndNoOtherToolHeld;
public static ConfigEntry<bool> ShowLabelOnScrap;
public static ConfigEntry<float> ScrapLabelScaleFactor;
public static ConfigEntry<bool> HideScrapLabelIfOnShip;
public static ConfigEntry<bool> HideScrapLabelIfCarried;
public static ConfigEntry<int> HighValueScrapThreshold;
public static ConfigEntry<bool> HideScrapLabelOnNutcracker;
public static ConfigEntry<bool> ShowLabelOnEnemies;
public static ConfigEntry<bool> ShowLabelOnDeadEnemies;
public static ConfigEntry<bool> HideLabelOnSomeEnemies;
public static ConfigEntry<string> UnknownLabel;
public static ConfigEntry<string> BaboonHawkLabel;
public static ConfigEntry<string> BlobLabel;
public static ConfigEntry<string> CentipedeLabel;
public static ConfigEntry<string> CrawlerLabel;
public static ConfigEntry<string> ManticoilLabel;
public static ConfigEntry<string> BrackenLabel;
public static ConfigEntry<string> ForestGiantLabel;
public static ConfigEntry<string> HoarderBugLabel;
public static ConfigEntry<string> JesterLabel;
public static ConfigEntry<string> MaskedLabel;
public static ConfigEntry<string> DogLabel;
public static ConfigEntry<string> NutCrackerLabel;
public static ConfigEntry<string> SporeLizardLabel;
public static ConfigEntry<string> SpiderLabel;
public static ConfigEntry<string> SandWormLabel;
public static ConfigEntry<string> CoilHeadLabel;
public static ConfigEntry<string> ButlerLabel;
public static ConfigEntry<string> RadMechLabel;
public static ConfigEntry<string> FlowerSnakeLabel;
public static ConfigEntry<string> ManeaterLabel;
public static ConfigEntry<string> BabyManeaterLabel;
public static ConfigEntry<string> ClaySurgeonLabel;
public static ConfigEntry<string> BushWolfLabel;
public static ConfigEntry<Color> DeadPlayerLabelColour;
public static ConfigEntry<Color> TargetPlayerLabelColour;
public static ConfigEntry<Color> DefaultPlayerLabelColour;
public static ConfigEntry<Color> PlayerFullHealthColour;
public static ConfigEntry<Color> PlayerHalfHealthColour;
public static ConfigEntry<Color> PlayerCriticalHealthColour;
public static ConfigEntry<Color> TargetRadarBoosterLabelColour;
public static ConfigEntry<Color> RadarBoosterLabelColour;
public static ConfigEntry<Color> EnemyLabelColour;
public static ConfigEntry<Color> DeadEnemyLabelColour;
public static ConfigEntry<Color> ToolLabelColour;
public static ConfigEntry<Color> CarriedToolLabelColour;
public static ConfigEntry<Color> InShipToolLabelColour;
public static ConfigEntry<Color> ScrapLabelColour;
public static ConfigEntry<Color> HighValueScrapLabelColour;
public static ConfigEntry<Color> CarriedScrapLabelColour;
public static ConfigEntry<Color> InShipScrapLabelColour;
public static ConfigEntry<Vector2> RadarTargetLabelOffset;
public static ConfigEntry<Vector2> EnemyLabelOffset;
public static ConfigEntry<Vector2> ToolLabelOffset;
public static ConfigEntry<Vector2> ScrapLabelOffset;
public static ConfigEntry<bool> RemoveDetonatedMineLabel;
public static ConfigEntry<string> PlayerLabelStringFormat;
public static ConfigEntry<string> PlayerCarriedScrapValueStringFormat;
public static ConfigEntry<string> ScrapLabelStringFormat;
public static ConfigEntry<string> ToolLabelStringFormat;
public static ConfigEntry<string> ToolBatteryStringFormat;
private static ConfigFile config;
internal static void Initialize(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<LogLevel>("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<int>("1.1 RadarTarget/Player", "maximumNameLength", 5, "The maximum length of the name that will be shown on the terminal");
ShowLabelOnTarget = config.Bind<bool>("1.1 RadarTarget/Player", "showLabelOnTarget", true, "Should the currently targeted player also show a label");
ForceDeadPlayerLabel = config.Bind<bool>("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<string>("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<bool>("1.1 RadarTarget/Player", "hidePlayerLabels", false, "Don't use any player labels except for 'forceDeadPlayerLabel'");
HideDeadPlayerLabels = config.Bind<bool>("1.1 RadarTarget/Player", "hideDeadPlayerLabels", false, "Don't use labels for dead players");
UseColorsToShowPlayerHealth = config.Bind<bool>("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<bool>("1.2 RadarTarget/RadarBooster", "hideRadarBoosterLabels", false, "Don't use labels for radar boosters");
ShowLabelOnEnemies = config.Bind<bool>("2.1 Enemies", "showLabelOnEnemies", true, "Should enemies have labels?");
ShowLabelOnDeadEnemies = config.Bind<bool>("2.1 Enemies", "showLabelOnDeadEnemies", false, "Should the label stay on a dead enemy?");
HideLabelOnSomeEnemies = config.Bind<bool>("2.1 Enemies", "hideLabelOnSomeEnemies", true, "Don't show a label for the following enemies:\nManticoil\nWorm");
UnknownLabel = config.Bind<string>("2.2 Enemy Labels", "unknownLabel", string.Empty, "The label of an unidentified enemy, leave empty to use the name");
BaboonHawkLabel = config.Bind<string>("2.2 Enemy Labels", "baboonHawkLabel", "Hawk", "The label of the BaboonBird enemy");
BlobLabel = config.Bind<string>("2.2 Enemy Labels", "blobLabel", "Blob", "The label of the Blob enemy");
CentipedeLabel = config.Bind<string>("2.2 Enemy Labels", "snareFleaLabel", "Snare", "The label of the Centipede (Snare Flea) enemy");
CrawlerLabel = config.Bind<string>("2.2 Enemy Labels", "crawlerLabel", "Half", "The label of the Crawler (Thumper) enemy");
ManticoilLabel = config.Bind<string>("2.2 Enemy Labels", "manticoilLabel", "Bird", "The label of the Doublewing (Manticoil) enemy");
BrackenLabel = config.Bind<string>("2.2 Enemy Labels", "brackenLabel", "Bracken", "The label of the FlowerMan (Bracken) enemy");
ForestGiantLabel = config.Bind<string>("2.2 Enemy Labels", "forestGiantLabel", "Giant", "The label of the ForestGiant enemy");
HoarderBugLabel = config.Bind<string>("2.2 Enemy Labels", "hoarderBugLabel", "Bug", "The label of the HoarderBug enemy");
JesterLabel = config.Bind<string>("2.2 Enemy Labels", "jesterLabel", "Jester", "The label of the Jester enemy");
MaskedLabel = config.Bind<string>("2.2 Enemy Labels", "maskedPlayerLabel", "X", "The label of the MaskedPlayer enemy");
DogLabel = config.Bind<string>("2.2 Enemy Labels", "mouthDogLabel", "Dog", "The label of the MouthDog enemy");
NutCrackerLabel = config.Bind<string>("2.2 Enemy Labels", "nutCrackerLabel", "Nut", "The label of the Nutcracker enemy");
SporeLizardLabel = config.Bind<string>("2.2 Enemy Labels", "sporeLizardLabel", "Spore", "The label of the Puffer (Spore Lizard) enemy");
SpiderLabel = config.Bind<string>("2.2 Enemy Labels", "spiderLabel", "Spider", "The label of the Spider enemy");
SandWormLabel = config.Bind<string>("2.2 Enemy Labels", "sandWormLabel", string.Empty, "The label of the SandWorm enemy");
CoilHeadLabel = config.Bind<string>("2.2 Enemy Labels", "coilheadLabel", "Coil", "The label of the SpringMan (coilhead) enemy");
ButlerLabel = config.Bind<string>("2.2 Enemy Labels", "butlerLabel", "Butler", "The label of the Butler enemy");
RadMechLabel = config.Bind<string>("2.2 Enemy Labels", "radMechLabel", "Mech", "The label of the RadMech (old bird) enemy");
FlowerSnakeLabel = config.Bind<string>("2.2 Enemy Labels", "flowerSnakeLabel", "Snake", "The label of the FlowerSnake (Tulip Snake) enemy");
BushWolfLabel = config.Bind<string>("2.2 Enemy Labels", "bushWolfLabel", "Fox", "The label of the BushWolf (Kidnapper Fox) enemy");
ManeaterLabel = config.Bind<string>("2.2 Enemy Labels", "maneaterLabel", "Maneater", "The label of the CaveDweller (Maneater) enemy");
BabyManeaterLabel = config.Bind<string>("2.2 Enemy Labels", "babyManeaterLabel", "Baby", "The label of the CaveDweller (Maneater) enemy when in 'baby' state");
ClaySurgeonLabel = config.Bind<string>("2.2 Enemy Labels", "claySurgeonLabel", "Barber", "The label of the ClaySurgeon (Barber) enemy");
ShowIconOnTools = config.Bind<bool>("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<bool>("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<bool>("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<float>("3.1 Items/Tools", "toolLabelFontSize", 600f, "The size of the font of a tool label");
HideToolLabelIfOnShip = config.Bind<bool>("3.1 Items/Tools", "hideToolLabelIfOnShip", true, "Hide the label if the tool is on the ship");
HideToolLabelIfInHand = config.Bind<bool>("3.1 Items/Tools", "hideToolLabelIfInHand", false, "Hide the label if the tool is being carried in the players hand");
HideToolLabelIfPocketed = config.Bind<bool>("3.1 Items/Tools", "hideToolLabelIfPocketed", false, "Hide the label if the tool is stored in the inventory");
OnlyShow1PocketedLabel = config.Bind<bool>("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<bool>("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<bool>("3.2 Items/Scrap", "showLabelOnScrap", true, "Should scrap also have a label?");
ScrapLabelScaleFactor = config.Bind<float>("3.2 Items/Scrap", "scrapLabelScaleFactor", 3.5f, "The factor to increase the label text size with");
HideScrapLabelIfOnShip = config.Bind<bool>("3.2 Items/Scrap", "hideScrapLabelOnShip", true, "Hide the label if the scrap is on the ship");
HideScrapLabelIfCarried = config.Bind<bool>("3.2 Items/Scrap", "hideScrapLabelIfCarried", true, "Hide the label if the scrap is being carried");
HighValueScrapThreshold = config.Bind<int>("3.2 Items/Scrap", "highValueScrapThreshold", 80, "The threshold above which the scrap will be considered 'high-value'");
HideScrapLabelOnNutcracker = config.Bind<bool>("3.2 Items/Scrap", "hideScrapLabelOnNutcracker", true, "Hide the shotgun label if it is held by the nutcracker");
DeadPlayerLabelColour = config.Bind<Color>("4.1 Colours/Players", "deadPlayerLabelColour", Color.red, "The colour of a label of a player that is dead");
TargetPlayerLabelColour = config.Bind<Color>("4.1 Colours/Players", "targetPlayerLabelColour", Color.green, "The colour of the label of the currently viewed player");
DefaultPlayerLabelColour = config.Bind<Color>("4.1 Colours/Players", "defaultPlayerLabelColour", Color.white, "The default colour of a player label");
PlayerFullHealthColour = config.Bind<Color>("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<Color>("4.1 Colours/Players", "playerHalfHealthColour", new Color(1f, 0.31f, 0.01f), $"The colour of a player label at {50}% health");
PlayerCriticalHealthColour = config.Bind<Color>("4.1 Colours/Players", "playerCriticalHealthColour", new Color(0.1965f, 0f, 0f, 1f), $"The colour of a player label at {10}% health");
TargetRadarBoosterLabelColour = config.Bind<Color>("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<Color>("4.2 Colours/RadarBooster", "radarBoosterLabelColour", Color.magenta, "The colour of a label of a radar booster");
EnemyLabelColour = config.Bind<Color>("4.3 Colours/Enemies", "enemyLabelColour", new Color(1f, 0.5f, 0.2f, 1f), "The colour of a label of an enemy");
DeadEnemyLabelColour = config.Bind<Color>("4.3 Colours/Enemies", "deadEnemyLabelColour", Color.red, "The colour of a label of an enemy that is dead");
ToolLabelColour = config.Bind<Color>("4.4 Colours/Tools", "toolLabelColour", new Color(1f, 0.5f, 0.2f, 1f), "The colour of the label of tools");
CarriedToolLabelColour = config.Bind<Color>("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<Color>("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<Color>("4.5 Colours/Scrap", "scrapLabelColour", Color.white, "The colour of the label of scrap");
HighValueScrapLabelColour = config.Bind<Color>("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<Color>("4.5 Colours/Scrap", "carriedScrapLabelColour", Color.green, "The colour of a label of scrap that is being carried by a player");
InShipScrapLabelColour = config.Bind<Color>("4.5 Colours/Scrap", "inShipScrapLabelColour", Color.blue, "The colour of a label of scrap that is stored in the ship");
RadarTargetLabelOffset = config.Bind<Vector2>("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<Vector2>("5.2 Label Offsets/Enemies", "enemyLabelOffset", Vector2.down * 0.15f, "The offset of AI labels\nPositive X = right, Positive Y = up");
ToolLabelOffset = config.Bind<Vector2>("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<Vector2>("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<Vector2>("5.3 Label Offsets/Items", "scrapLabelOffset", Vector2.up * 1.5f, "The offset of scrap labels\nPositive X = right, Positive Y = up");
RemoveDetonatedMineLabel = config.Bind<bool>("9. Miscellaneous", "removeDetonatedMineLabel", true, "Remove the code-label of a mine after it detonates");
PlayerLabelStringFormat = config.Bind<string>("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<string>("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<string>("99. Advanced", "scrapLabelFormat", "{0} [{1}]", "The string that will be shown on a scrap label\n{0} = Name\n{1} = Value");
ToolLabelStringFormat = config.Bind<string>("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<string>("99. Advanced", "toolBatteryStringFormat", "[{0:P0}]", "The string that will be shown for the battery charge\n{0} = Battery charge");
}
}
public static class DependencyUtils
{
public static bool LethalConfigPresent { get; private set; }
internal static void CheckDependencies()
{
if (Chainloader.PluginInfos.TryGetValue("ainavt.lc.lethalconfig", out var value))
{
LoggerUtil.LogInfo(value.Metadata.Name + " has been found!\nAdding apply button to config...");
LethalConfigPresent = true;
LethalConfigUtils.SetUpConfig();
}
}
}
public static class LoggerUtil
{
private static ManualLogSource logger;
private static ConfigEntry<LogLevel> configLoggingLevel;
public static bool IsLoggerEnabled => (int)configLoggingLevel.Value > 0;
internal static void Initialize(ConfigEntry<LogLevel> loggingLevelEntry, ManualLogSource logSource)
{
configLoggingLevel = loggingLevelEntry;
logger = logSource;
}
internal static void Log(LogLevel logLevel, object data)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
if (IsLoggerEnabled)
{
logger.Log(logLevel, data);
}
}
internal static void LogMessage(object data)
{
//IL_0005: 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)
if ((configLoggingLevel.Value & 8) != 0)
{
Log((LogLevel)8, data);
}
}
internal static void LogInfo(object data)
{
//IL_0005: 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)
if ((configLoggingLevel.Value & 0x10) != 0)
{
Log((LogLevel)16, data);
}
}
internal static void LogDebug(object data)
{
//IL_0005: 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)
if ((configLoggingLevel.Value & 0x20) != 0)
{
Log((LogLevel)32, data);
}
}
internal static void LogError(object data)
{
//IL_0005: 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)
if ((configLoggingLevel.Value & 2) != 0)
{
Log((LogLevel)2, data);
}
}
internal static void LogWarning(object data)
{
//IL_0005: 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)
if ((configLoggingLevel.Value & 4) != 0)
{
Log((LogLevel)4, data);
}
}
internal static void LogFatal(object data)
{
//IL_0005: 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)
if ((configLoggingLevel.Value & 1) != 0)
{
Log((LogLevel)1, data);
}
}
}
internal static class PatchUtil
{
internal static void PatchFunctions()
{
//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("DannyVD.mods.LethalCompany.MonitorLabels");
LoggerUtil.LogInfo("Attempting to patch with Harmony!");
try
{
val.PatchAll(typeof(Patches));
LoggerUtil.Log((LogLevel)16, "Patching success!");
}
catch (Exception ex)
{
LoggerUtil.Log((LogLevel)2, "Failed to patch: " + ex);
}
}
}
}
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.Dependencies.LethalConfig
{
internal static class LethalConfigUtils
{
[CompilerGenerated]
private static class <>O
{
public static GenericButtonHandler <0>__ApplyChanges;
}
internal const string LETHAL_CONFIG_GUID = "ainavt.lc.lethalconfig";
internal static void SetUpConfig()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
//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_002f: Expected O, but got Unknown
object obj = <>O.<0>__ApplyChanges;
if (obj == null)
{
GenericButtonHandler val = ApplyChanges;
<>O.<0>__ApplyChanges = val;
obj = (object)val;
}
LethalConfigManager.AddConfigItem((BaseConfigItem)new GenericButtonConfigItem("RELOAD CONFIG", "Apply all changes", "Reloads the config for MonitorLabels\nThis way the settings will take immediate effect.", "Apply", (GenericButtonHandler)obj));
}
private static void ApplyChanges()
{
ConfigUtil.ReadConfig();
}
}
}
namespace MonitorLabels.Constants
{
public static class Colors
{
public static readonly Color DevColor = new Color(0.52f, 0f, 0.56f);
}
public static class SteamIDs
{
public const ulong MY_ID = 76561198166372065uL;
}
}
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<bool>)(() => 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.ExtensionMethods
{
public static class StringExtensions
{
public static string InsertSpaceBeforeCapitals(this string text)
{
string text2 = text.ToUpper();
string text3 = text;
int length = text.Length;
if ((uint)length <= 1u)
{
return text3;
}
for (int num = text.Length - 1; num >= 1; num--)
{
if (text[num] == text2[num])
{
text3 = text3.Insert(num, " ");
}
}
return text3;
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
