using System;
using System.Collections.Generic;
using System.Diagnostics;
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 Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace OtherPlayerStatusBars
{
internal sealed class CadaverGrowthInfectionProvider
{
private Type? cadaverGrowthType;
private FieldInfo? playerInfectionsField;
private FieldInfo? infectionMeterField;
private Object? cachedCadaverGrowthInstance;
private float nextFindTime;
public bool TryGetNormalizedInfection(PlayerControllerB player, out float infectionMeter)
{
infectionMeter = 0f;
if ((Object)(object)player == (Object)null)
{
return false;
}
if (!TryResolveCadaverGrowthInstance(out object instance))
{
return false;
}
if (!(playerInfectionsField?.GetValue(instance) is Array array))
{
return false;
}
int num = (int)player.playerClientId;
if (num < 0 || num >= array.Length)
{
return false;
}
object value = array.GetValue(num);
if (value == null || infectionMeterField == null)
{
return false;
}
if (!(infectionMeterField.GetValue(value) is float num2))
{
return false;
}
infectionMeter = Mathf.Clamp01(num2);
return true;
}
private bool TryResolveCadaverGrowthInstance(out object instance)
{
instance = null;
if (!TryResolveCadaverGrowthMetadata())
{
return false;
}
if (cachedCadaverGrowthInstance == (Object)null && Time.unscaledTime >= nextFindTime)
{
nextFindTime = Time.unscaledTime + 1f;
cachedCadaverGrowthInstance = Object.FindObjectOfType(cadaverGrowthType);
}
if (cachedCadaverGrowthInstance == (Object)null)
{
return false;
}
instance = cachedCadaverGrowthInstance;
return true;
}
private bool TryResolveCadaverGrowthMetadata()
{
if (cadaverGrowthType != null && playerInfectionsField != null && infectionMeterField != null)
{
return true;
}
cadaverGrowthType = (from assembly in AppDomain.CurrentDomain.GetAssemblies()
select assembly.GetType("CadaverGrowthAI", throwOnError: false)).FirstOrDefault((Type type) => type != null);
if (cadaverGrowthType == null)
{
return false;
}
playerInfectionsField = cadaverGrowthType.GetField("playerInfections", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (playerInfectionsField == null)
{
return false;
}
Type type2 = cadaverGrowthType.GetNestedType("PlayerInfection", BindingFlags.Public | BindingFlags.NonPublic);
if (type2 == null)
{
type2 = playerInfectionsField.FieldType.GetElementType();
}
if (type2 == null)
{
return false;
}
infectionMeterField = type2.GetField("infectionMeter", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
return infectionMeterField != null;
}
}
internal static class MyPluginInfo
{
public const string PluginGuid = "Codex.OtherPlayerStatusBars";
public const string PluginName = "OtherPlayerStatusBars";
public const string PluginVersion = "0.1.1";
}
internal sealed class PlayerStatusBarManager : MonoBehaviour
{
private readonly Dictionary<int, PlayerStatusBarView> trackedBars = new Dictionary<int, PlayerStatusBarView>();
private readonly HashSet<int> seenPlayerIds = new HashSet<int>();
private readonly List<int> staleIds = new List<int>();
private float nextRefreshTime;
private void Update()
{
if (!Plugin.Settings.Enabled)
{
ClearBars();
}
else if (!(Time.unscaledTime < nextRefreshTime))
{
nextRefreshTime = Time.unscaledTime + 0.5f;
RefreshBars();
}
}
private void RefreshBars()
{
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Expected O, but got Unknown
StartOfRound instance = StartOfRound.Instance;
PlayerControllerB val = (((Object)(object)GameNetworkManager.Instance != (Object)null) ? GameNetworkManager.Instance.localPlayerController : instance?.localPlayerController);
if ((Object)(object)instance == (Object)null || (Object)(object)val == (Object)null || instance.allPlayerScripts == null)
{
ClearBars();
return;
}
if (ShouldSkipBarsInOrbit(instance))
{
ClearBars();
return;
}
seenPlayerIds.Clear();
PlayerControllerB[] allPlayerScripts = instance.allPlayerScripts;
foreach (PlayerControllerB val2 in allPlayerScripts)
{
if (!ShouldTrackPlayer(val2, val, allPlayerScripts))
{
continue;
}
int num = (int)val2.playerClientId;
seenPlayerIds.Add(num);
if (!trackedBars.ContainsKey(num))
{
GameObject val3 = new GameObject($"OtherPlayerStatusBar_{num}");
val3.transform.SetParent(((Component)this).transform, false);
PlayerStatusBarView playerStatusBarView = val3.AddComponent<PlayerStatusBarView>();
if (!playerStatusBarView.Initialize(val2))
{
Object.Destroy((Object)(object)val3);
Plugin.Log.LogWarning((object)$"Failed to create player status bar for playerId={num}.");
}
else
{
trackedBars[num] = playerStatusBarView;
}
}
}
staleIds.Clear();
foreach (KeyValuePair<int, PlayerStatusBarView> trackedBar in trackedBars)
{
if (!seenPlayerIds.Contains(trackedBar.Key) || (Object)(object)trackedBar.Value == (Object)null || !trackedBar.Value.IsStillValid(val))
{
staleIds.Add(trackedBar.Key);
}
}
for (int j = 0; j < staleIds.Count; j++)
{
RemoveBar(staleIds[j]);
}
}
private static bool ShouldTrackPlayer(PlayerControllerB player, PlayerControllerB localPlayer, PlayerControllerB[] allPlayers)
{
if ((Object)(object)player == (Object)null || (Object)(object)localPlayer == (Object)null)
{
return false;
}
if ((Object)(object)player == (Object)(object)localPlayer)
{
return false;
}
if (!player.isPlayerControlled || player.isPlayerDead)
{
return false;
}
if (player.health <= 0)
{
return false;
}
int num = (int)player.playerClientId;
if (num < 0 || num >= allPlayers.Length || (Object)(object)allPlayers[num] != (Object)(object)player)
{
return false;
}
return ((Component)player).gameObject.activeInHierarchy;
}
private static bool ShouldSkipBarsInOrbit(StartOfRound startOfRound)
{
if (Plugin.Settings.HideInOrbit && startOfRound.inShipPhase)
{
return !startOfRound.shipHasLanded;
}
return false;
}
private void RemoveBar(int playerId)
{
if (trackedBars.TryGetValue(playerId, out PlayerStatusBarView value))
{
trackedBars.Remove(playerId);
if ((Object)(object)value != (Object)null)
{
Object.Destroy((Object)(object)((Component)value).gameObject);
}
}
}
private void ClearBars()
{
foreach (KeyValuePair<int, PlayerStatusBarView> trackedBar in trackedBars)
{
if ((Object)(object)trackedBar.Value != (Object)null)
{
Object.Destroy((Object)(object)((Component)trackedBar.Value).gameObject);
}
}
trackedBars.Clear();
}
private void OnDestroy()
{
ClearBars();
}
private void OnEnable()
{
Plugin.Settings.SettingsChanged += HandleSettingsChanged;
}
private void OnDisable()
{
Plugin.Settings.SettingsChanged -= HandleSettingsChanged;
}
private void HandleSettingsChanged()
{
nextRefreshTime = 0f;
}
}
internal sealed class PlayerStatusBarStrip : MonoBehaviour
{
internal enum StripType
{
Health,
Infection
}
private const float Width = 172f;
private const float Height = 20f;
private bool visible = true;
private string label = string.Empty;
private float currentValue;
private float maxValue = 1f;
private bool renderAsPercent;
private bool labelOnly;
private StripType stripType;
private RectTransform rectTransform;
private Image backgroundImage;
private Image fillImage;
private TextMeshProUGUI text;
private Outline border;
private RectTransform fillRect;
private bool dirty = true;
private bool lastAppliedVisible = true;
private float lastAppliedNormalized = -1f;
private string lastAppliedText = string.Empty;
private bool lastAppliedTextEnabled = true;
private Color lastAppliedBackgroundColor = Color.clear;
private Color lastAppliedFillColor = Color.clear;
private Color lastAppliedBorderColor = Color.clear;
private int lastAppliedSettingsRevision = -1;
private bool hasFillColorOverride;
private Color fillColorOverride;
public void Initialize(StripType type)
{
//IL_0047: 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_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Expected O, but got Unknown
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
//IL_0157: Unknown result type (might be due to invalid IL or missing references)
//IL_015d: Expected O, but got Unknown
//IL_0181: Unknown result type (might be due to invalid IL or missing references)
//IL_0196: Unknown result type (might be due to invalid IL or missing references)
//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
//IL_0217: Unknown result type (might be due to invalid IL or missing references)
//IL_021d: Expected O, but got Unknown
//IL_0236: Unknown result type (might be due to invalid IL or missing references)
//IL_0241: Unknown result type (might be due to invalid IL or missing references)
//IL_0256: Unknown result type (might be due to invalid IL or missing references)
//IL_026a: Unknown result type (might be due to invalid IL or missing references)
//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
stripType = type;
rectTransform = ((Component)this).gameObject.GetComponent<RectTransform>();
if ((Object)(object)rectTransform == (Object)null)
{
rectTransform = ((Component)this).gameObject.AddComponent<RectTransform>();
}
rectTransform.sizeDelta = new Vector2(172f, 20f);
rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
rectTransform.pivot = new Vector2(0.5f, 0.5f);
GameObject val = new GameObject("Background", new Type[3]
{
typeof(RectTransform),
typeof(Image),
typeof(Outline)
});
val.transform.SetParent(((Component)this).transform, false);
RectTransform component = val.GetComponent<RectTransform>();
component.anchorMin = Vector2.zero;
component.anchorMax = Vector2.one;
component.offsetMin = Vector2.zero;
component.offsetMax = Vector2.zero;
backgroundImage = val.GetComponent<Image>();
border = val.GetComponent<Outline>();
GameObject val2 = new GameObject("Fill", new Type[2]
{
typeof(RectTransform),
typeof(Image)
});
val2.transform.SetParent(val.transform, false);
RectTransform component2 = val2.GetComponent<RectTransform>();
component2.anchorMin = new Vector2(0f, 0f);
component2.anchorMax = new Vector2(0f, 1f);
component2.pivot = new Vector2(0f, 0.5f);
component2.offsetMin = new Vector2(1f, 1f);
component2.offsetMax = new Vector2(-1f, -1f);
fillImage = val2.GetComponent<Image>();
fillRect = component2;
GameObject val3 = new GameObject("Text", new Type[2]
{
typeof(RectTransform),
typeof(TextMeshProUGUI)
});
val3.transform.SetParent(val.transform, false);
RectTransform component3 = val3.GetComponent<RectTransform>();
component3.anchorMin = Vector2.zero;
component3.anchorMax = Vector2.one;
component3.offsetMin = new Vector2(6f, 1f);
component3.offsetMax = new Vector2(-6f, -1f);
text = val3.GetComponent<TextMeshProUGUI>();
((TMP_Text)text).alignment = (TextAlignmentOptions)514;
((TMP_Text)text).fontSize = 12f;
((TMP_Text)text).enableWordWrapping = false;
((Graphic)text).color = Color.white;
}
public void SetDisplay(string displayLabel, float value, float max, bool showPercent)
{
float num = Mathf.Clamp(value, 0f, (max <= 0f) ? 1f : max);
float num2 = Mathf.Max(max, 0.0001f);
if (label == displayLabel && Mathf.Approximately(currentValue, num) && Mathf.Approximately(maxValue, num2) && renderAsPercent == showPercent && !labelOnly)
{
visible = true;
return;
}
label = displayLabel;
currentValue = num;
maxValue = num2;
renderAsPercent = showPercent;
labelOnly = false;
visible = true;
dirty = true;
}
public void SetLabelOnly(string displayLabel, float fillValue, float max)
{
float num = Mathf.Clamp(fillValue, 0f, (max <= 0f) ? 1f : max);
float num2 = Mathf.Max(max, 0.0001f);
if (label == displayLabel && Mathf.Approximately(currentValue, num) && Mathf.Approximately(maxValue, num2) && labelOnly)
{
visible = true;
return;
}
label = displayLabel;
currentValue = num;
maxValue = num2;
renderAsPercent = false;
labelOnly = true;
visible = true;
dirty = true;
}
public void SetVisible(bool isVisible)
{
if (visible != isVisible || ((Component)this).gameObject.activeSelf != isVisible)
{
visible = isVisible;
((Component)this).gameObject.SetActive(isVisible);
dirty = true;
}
}
public void SetFillColorOverride(bool enabled, Color color)
{
//IL_0023: 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_000d: 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)
if (hasFillColorOverride != enabled || (enabled && !(fillColorOverride == color)))
{
hasFillColorOverride = enabled;
fillColorOverride = color;
dirty = true;
}
}
private void LateUpdate()
{
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: 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_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: 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_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Unknown result type (might be due to invalid IL or missing references)
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
//IL_012c: Unknown result type (might be due to invalid IL or missing references)
//IL_012e: Unknown result type (might be due to invalid IL or missing references)
//IL_013a: Unknown result type (might be due to invalid IL or missing references)
//IL_013d: Unknown result type (might be due to invalid IL or missing references)
//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
//IL_01f7: 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_01ff: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)backgroundImage == (Object)null || (Object)(object)fillImage == (Object)null || (Object)(object)this.text == (Object)null || !visible)
{
return;
}
StatusBarConfig settings = Plugin.Settings;
if (!dirty && settings.Revision == lastAppliedSettingsRevision)
{
return;
}
float num = Mathf.Clamp01(currentValue / maxValue);
Color val = ((stripType == StripType.Health) ? settings.GetHealthFillColor() : settings.GetInfectionFillColor());
if (hasFillColorOverride)
{
val = fillColorOverride;
}
Color backgroundColor = settings.GetBackgroundColor();
Color borderColor = settings.GetBorderColor();
bool flag = ((stripType == StripType.Health) ? settings.ShowHealthText : settings.ShowInfectionText);
string text = (labelOnly ? label : (renderAsPercent ? $"{label} {Mathf.RoundToInt(num * 100f)}%" : $"{label} {Mathf.RoundToInt(currentValue)}/{Mathf.RoundToInt(maxValue)}"));
bool flag2 = backgroundColor != lastAppliedBackgroundColor || val != lastAppliedFillColor || borderColor != lastAppliedBorderColor;
bool flag3 = !Mathf.Approximately(num, lastAppliedNormalized);
bool flag4 = flag != lastAppliedTextEnabled;
bool flag5 = text != lastAppliedText;
bool flag6 = visible != lastAppliedVisible;
if (dirty || flag2 || flag3 || flag4 || flag5 || flag6)
{
if (flag2)
{
((Graphic)backgroundImage).color = backgroundColor;
((Shadow)border).effectColor = borderColor;
((Shadow)border).effectDistance = new Vector2(1f, -1f);
((Graphic)fillImage).color = val;
lastAppliedBackgroundColor = backgroundColor;
lastAppliedFillColor = val;
lastAppliedBorderColor = borderColor;
}
if (dirty || flag3)
{
fillRect.SetSizeWithCurrentAnchors((Axis)0, Mathf.Lerp(0f, 170f, num));
lastAppliedNormalized = num;
}
if (dirty || flag4)
{
((Behaviour)this.text).enabled = flag;
lastAppliedTextEnabled = flag;
}
if (flag && (dirty || flag5))
{
((TMP_Text)this.text).text = text;
lastAppliedText = text;
}
lastAppliedVisible = visible;
lastAppliedSettingsRevision = settings.Revision;
dirty = false;
}
}
}
internal sealed class PlayerStatusBarView : MonoBehaviour
{
private static readonly Color CriticalHealthBarColor = new Color(0.88f, 0.15f, 0.12f, 0.95f);
private const float LowHealthRecoveryDisplayDelay = 15f;
private const float LowHealthConfirmDelay = 0.5f;
private const float InitialStateStabilizationDelay = 3f;
private readonly CadaverGrowthInfectionProvider infectionProvider = new CadaverGrowthInfectionProvider();
private PlayerControllerB targetPlayer;
private PlayerControllerB? localPlayer;
private Transform? anchor;
private PlayerStatusBarStrip healthStrip;
private PlayerStatusBarStrip infectionStrip;
private RectTransform healthStripRect;
private RectTransform infectionStripRect;
private Canvas worldCanvas;
private RectTransform canvasRect;
private int lastDisplayedHealth = int.MinValue;
private int lastDisplayedInfectionPercent = int.MinValue;
private bool wasHealthVisible;
private bool wasInfectionVisible;
private bool isLowHealthRecoveryTiming;
private float lowHealthRecoveryTimer;
private bool isLowHealthConfirming;
private float lowHealthConfirmTimer;
private string lastDisplayedHealthLabel = string.Empty;
private bool lastCanvasEnabled = true;
private float lastAppliedUiScale = -1f;
private float lastAppliedHealthBarYOffset = float.NaN;
private float lastAppliedInfectionBarYOffset = float.NaN;
private float initializedAtTime;
private bool suppressInitialStaleCriticalState;
private bool suppressInitialStaleHealthState;
private bool hasCompletedInitialStateStabilization;
private bool hasObservedStableNonCriticalState;
public int PlayerId
{
get
{
if (!((Object)(object)targetPlayer != (Object)null))
{
return -1;
}
return (int)targetPlayer.playerClientId;
}
}
public bool Initialize(PlayerControllerB player)
{
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
targetPlayer = player;
anchor = ResolveAnchor(player);
initializedAtTime = Time.unscaledTime;
((Component)this).gameObject.AddComponent<StatusBarBillboard>();
worldCanvas = ((Component)this).gameObject.AddComponent<Canvas>();
worldCanvas.renderMode = (RenderMode)2;
worldCanvas.sortingOrder = 50;
((Component)this).gameObject.AddComponent<CanvasScaler>();
canvasRect = ((Component)worldCanvas).GetComponent<RectTransform>();
canvasRect.sizeDelta = new Vector2(220f, 84f);
if (!TryCreateStrip("HealthStrip", out healthStrip))
{
return false;
}
healthStripRect = ((Component)healthStrip).GetComponent<RectTransform>();
if (!TryCreateStrip("InfectionStrip", out infectionStrip))
{
return false;
}
infectionStripRect = ((Component)infectionStrip).GetComponent<RectTransform>();
((Object)this).name = $"PlayerStatusBar_{player.playerClientId}";
return true;
}
public bool IsStillValid(PlayerControllerB localPlayer)
{
if ((Object)(object)targetPlayer == (Object)null || (Object)(object)localPlayer == (Object)null)
{
return false;
}
if ((Object)(object)targetPlayer == (Object)(object)localPlayer || !targetPlayer.isPlayerControlled || targetPlayer.isPlayerDead)
{
return false;
}
return ((Component)targetPlayer).gameObject.activeInHierarchy;
}
private void LateUpdate()
{
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: 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_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)targetPlayer == (Object)null)
{
return;
}
localPlayer = (((Object)(object)GameNetworkManager.Instance != (Object)null) ? GameNetworkManager.Instance.localPlayerController : StartOfRound.Instance?.localPlayerController);
bool flag = ShouldShowGroup();
if (anchor == null)
{
anchor = ResolveAnchor(targetPlayer);
}
float barSpacing = Plugin.Settings.BarSpacing;
Vector3 val = (((Object)(object)anchor != (Object)null) ? anchor.position : ((Component)targetPlayer).transform.position);
((Component)this).transform.position = val + Vector3.up * (Plugin.Settings.HeadOffset + barSpacing * Plugin.Settings.UiScale);
ApplyCanvasScale(Plugin.Settings.UiScale);
SetCanvasEnabled(flag);
if (!flag || !IsTargetReadyForDisplay())
{
healthStrip.SetVisible(isVisible: false);
infectionStrip.SetVisible(isVisible: false);
wasHealthVisible = false;
wasInfectionVisible = false;
ResetLowHealthFallbackState();
ResetInitialStateStabilization();
return;
}
bool flag2 = ShouldShowForDistance();
ApplyStripLayoutOffsets();
int num = Mathf.Clamp(targetPlayer.health, 0, 100);
bool criticallyInjured = targetPlayer.criticallyInjured;
bool bleedingHeavily = targetPlayer.bleedingHeavily;
bool flag3 = criticallyInjured || bleedingHeavily;
UpdateInitialStateStabilization(flag3, num);
bool flag4 = flag3 && !suppressInitialStaleCriticalState;
int num2 = ((suppressInitialStaleHealthState && num == 20 && !flag4) ? 100 : num);
bool flag5 = false;
if (!flag4 && num < 20 && !targetPlayer.isPlayerDead)
{
if (!isLowHealthRecoveryTiming)
{
if (!isLowHealthConfirming)
{
isLowHealthConfirming = true;
lowHealthConfirmTimer = 0f;
}
else
{
lowHealthConfirmTimer += Time.unscaledDeltaTime;
}
if (lowHealthConfirmTimer >= 0.5f)
{
isLowHealthRecoveryTiming = true;
lowHealthRecoveryTimer = 0f;
isLowHealthConfirming = false;
lowHealthConfirmTimer = 0f;
}
}
else
{
lowHealthRecoveryTimer += Time.unscaledDeltaTime;
}
if (isLowHealthRecoveryTiming && lowHealthRecoveryTimer < 15f)
{
flag5 = true;
}
else if (isLowHealthRecoveryTiming)
{
num2 = 20;
}
}
else if (isLowHealthRecoveryTiming || lowHealthRecoveryTimer > 0f || isLowHealthConfirming || lowHealthConfirmTimer > 0f)
{
ResetLowHealthFallbackState();
}
bool flag6 = flag2;
bool flag7 = flag4 || flag5;
string text = (flag7 ? GetCriticalHealthLabel() : "HP");
healthStrip.SetFillColorOverride(flag7, CriticalHealthBarColor);
if (flag6 && (!wasHealthVisible || num2 != lastDisplayedHealth || text != lastDisplayedHealthLabel))
{
if (flag7)
{
healthStrip.SetLabelOnly(text, 100f, 100f);
}
else
{
healthStrip.SetDisplay(text, num2, 100f, showPercent: false);
}
lastDisplayedHealth = num2;
lastDisplayedHealthLabel = text;
}
healthStrip.SetVisible(flag6);
wasHealthVisible = flag6;
float infectionMeter = 0f;
bool flag8 = false;
if (flag2)
{
flag8 = infectionProvider.TryGetNormalizedInfection(targetPlayer, out infectionMeter);
}
bool num3;
if (Plugin.Settings.InfectionDisplayMode != 0)
{
if (!(flag2 && flag8))
{
goto IL_03d6;
}
num3 = infectionMeter > 0f;
}
else
{
num3 = flag2;
}
if (num3)
{
int num4 = Mathf.Clamp(Mathf.RoundToInt(infectionMeter * 100f), 0, 100);
if (!wasInfectionVisible || num4 != lastDisplayedInfectionPercent)
{
infectionStrip.SetDisplay("INF", num4, 100f, showPercent: true);
lastDisplayedInfectionPercent = num4;
}
infectionStrip.SetVisible(isVisible: true);
wasInfectionVisible = true;
return;
}
goto IL_03d6;
IL_03d6:
infectionStrip.SetVisible(isVisible: false);
wasInfectionVisible = false;
}
private bool IsTargetReadyForDisplay()
{
if ((Object)(object)targetPlayer != (Object)null && targetPlayer.isPlayerControlled && !targetPlayer.isPlayerDead)
{
return targetPlayer.health > 0;
}
return false;
}
private void ResetLowHealthFallbackState()
{
isLowHealthRecoveryTiming = false;
lowHealthRecoveryTimer = 0f;
isLowHealthConfirming = false;
lowHealthConfirmTimer = 0f;
}
private static string GetCriticalHealthLabel()
{
if (!Plugin.UseChineseCriticalLabel)
{
return "CRITICAL";
}
return "重伤";
}
private void UpdateInitialStateStabilization(bool rawCriticalState, int rawHealth)
{
if (!rawCriticalState && rawHealth > 20)
{
hasObservedStableNonCriticalState = true;
}
if (!hasCompletedInitialStateStabilization)
{
float num = Time.unscaledTime - initializedAtTime;
if (num <= 3f && !hasObservedStableNonCriticalState)
{
if (rawHealth == 20)
{
suppressInitialStaleHealthState = true;
}
if (rawCriticalState && rawHealth >= 20)
{
suppressInitialStaleCriticalState = true;
suppressInitialStaleHealthState = true;
}
}
else if (num > 3f)
{
hasCompletedInitialStateStabilization = true;
}
}
if ((suppressInitialStaleCriticalState || suppressInitialStaleHealthState) && (targetPlayer.isPlayerDead || rawHealth < 20 || (!rawCriticalState && rawHealth > 20)))
{
suppressInitialStaleCriticalState = false;
suppressInitialStaleHealthState = false;
}
}
private void ResetInitialStateStabilization()
{
initializedAtTime = Time.unscaledTime;
suppressInitialStaleCriticalState = false;
suppressInitialStaleHealthState = false;
hasCompletedInitialStateStabilization = false;
hasObservedStableNonCriticalState = false;
}
private void ApplyCanvasScale(float uiScale)
{
//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)
if (!Mathf.Approximately(lastAppliedUiScale, uiScale))
{
((Transform)canvasRect).localScale = Vector3.one * uiScale;
lastAppliedUiScale = uiScale;
}
}
private void ApplyStripLayoutOffsets()
{
//IL_0025: 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)
float healthBarYOffset = Plugin.Settings.HealthBarYOffset;
if (!Mathf.Approximately(lastAppliedHealthBarYOffset, healthBarYOffset))
{
healthStripRect.anchoredPosition = new Vector2(0f, healthBarYOffset);
lastAppliedHealthBarYOffset = healthBarYOffset;
}
float infectionBarYOffset = Plugin.Settings.InfectionBarYOffset;
if (!Mathf.Approximately(lastAppliedInfectionBarYOffset, infectionBarYOffset))
{
infectionStripRect.anchoredPosition = new Vector2(0f, infectionBarYOffset);
lastAppliedInfectionBarYOffset = infectionBarYOffset;
}
}
private void SetCanvasEnabled(bool enabled)
{
if (lastCanvasEnabled != enabled || ((Behaviour)worldCanvas).enabled != enabled)
{
((Behaviour)worldCanvas).enabled = enabled;
lastCanvasEnabled = enabled;
}
}
private bool TryCreateStrip(string stripName, out PlayerStatusBarStrip strip)
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Expected O, but got Unknown
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
strip = null;
GameObject val = new GameObject(stripName, new Type[1] { typeof(RectTransform) });
val.transform.SetParent(((Component)worldCanvas).transform, false);
((Object)val).name = stripName;
val.transform.localPosition = Vector3.zero;
val.transform.localRotation = Quaternion.identity;
strip = val.AddComponent<PlayerStatusBarStrip>();
strip.Initialize((!(stripName == "HealthStrip")) ? PlayerStatusBarStrip.StripType.Infection : PlayerStatusBarStrip.StripType.Health);
return true;
}
private bool ShouldShowForDistance()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: 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)
if ((Object)(object)localPlayer == (Object)null)
{
return true;
}
float maxDistance = Plugin.Settings.MaxDistance;
float num = maxDistance * maxDistance;
Vector3 val = ((Component)localPlayer).transform.position - ((Component)targetPlayer).transform.position;
return ((Vector3)(ref val)).sqrMagnitude <= num;
}
private bool ShouldShowGroup()
{
if (!Plugin.Settings.HideInOrbit)
{
return true;
}
StartOfRound instance = StartOfRound.Instance;
if ((Object)(object)instance == (Object)null)
{
return true;
}
if (instance.inShipPhase)
{
return instance.shipHasLanded;
}
return true;
}
private static Transform? ResolveAnchor(PlayerControllerB player)
{
if ((Object)(object)player.playerGlobalHead != (Object)null)
{
return player.playerGlobalHead;
}
if (player.bodyParts != null && player.bodyParts.Length != 0 && (Object)(object)player.bodyParts[0] != (Object)null)
{
return player.bodyParts[0];
}
return ((Component)player).transform;
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("Codex.OtherPlayerStatusBars", "OtherPlayerStatusBars", "0.1.1")]
public sealed class Plugin : BaseUnityPlugin
{
internal static ManualLogSource Log { get; private set; }
internal static StatusBarConfig Settings { get; private set; }
internal static bool UseChineseCriticalLabel { get; private set; }
private void Awake()
{
Log = ((BaseUnityPlugin)this).Logger;
Settings = StatusBarConfig.Create(((BaseUnityPlugin)this).Config);
UseChineseCriticalLabel = DetectChineseLocalizationMod();
TryRegisterLethalConfig();
((Component)this).gameObject.AddComponent<PlayerStatusBarManager>();
((BaseUnityPlugin)this).Config.Save();
Log.LogInfo((object)"OtherPlayerStatusBars loaded.");
}
private static bool DetectChineseLocalizationMod()
{
foreach (PluginInfo value4 in Chainloader.PluginInfos.Values)
{
string value = value4.Metadata.GUID ?? string.Empty;
string value2 = value4.Metadata.Name ?? string.Empty;
string value3 = value4.Location ?? string.Empty;
if (LooksLikeChineseLocalization(value) || LooksLikeChineseLocalization(value2) || LooksLikeChineseLocalization(value3))
{
return true;
}
}
return false;
}
private static bool LooksLikeChineseLocalization(string value)
{
if (!Contains(value, "chinese") && !Contains(value, "simplified_chinese") && !Contains(value, "zh_cn") && !Contains(value, "zh-cn") && !Contains(value, "zh_hans") && !Contains(value, "zh-hans") && !Contains(value, "中文") && !Contains(value, "汉化"))
{
return Contains(value, "FixGameTranslate");
}
return true;
}
private static bool Contains(string value, string term)
{
return value.IndexOf(term, StringComparison.OrdinalIgnoreCase) >= 0;
}
private static void TryRegisterLethalConfig()
{
if (Type.GetType("LethalConfig.LethalConfigManager, LethalConfig", throwOnError: false) == null)
{
return;
}
try
{
StatusBarConfig.LethalConfigIntegration.Register(Settings);
}
catch (Exception arg)
{
Log.LogWarning((object)$"Failed to register LethalConfig items: {arg}");
}
}
}
internal sealed class StatusBarBillboard : MonoBehaviour
{
private void LateUpdate()
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_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_0028: 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_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: 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_004b: Unknown result type (might be due to invalid IL or missing references)
Camera val = ResolveViewCamera();
if (!((Object)(object)val == (Object)null))
{
Vector3 forward = ((Component)val).transform.forward;
Vector3 up = ((Component)val).transform.up;
if (!(forward == Vector3.zero) && !(up == Vector3.zero))
{
((Component)this).transform.rotation = Quaternion.LookRotation(forward, up);
}
}
}
private static Camera? ResolveViewCamera()
{
StartOfRound instance = StartOfRound.Instance;
if ((Object)(object)instance == (Object)null)
{
return Camera.current;
}
PlayerControllerB localPlayerController = instance.localPlayerController;
if ((Object)(object)localPlayerController != (Object)null && !localPlayerController.isPlayerDead)
{
return localPlayerController.gameplayCamera;
}
if (!((Object)(object)instance.spectateCamera != (Object)null))
{
return Camera.current;
}
return instance.spectateCamera;
}
}
internal sealed class StatusBarConfig
{
public enum InfectionBarDisplayMode
{
AlwaysVisible,
ShowOnlyWhenInfected
}
public enum ColorPreset
{
Green,
Red,
Orange,
Yellow,
Blue,
Cyan,
White,
Black,
Slate
}
public static class LethalConfigIntegration
{
public static void Register(StatusBarConfig config)
{
StatusBarConfig config2 = config;
AddBool(config2.enabled);
AddBool(config2.hideInOrbit);
AddFloat(config2.maxDistance, 2f, 80f);
AddFloat(config2.headOffset, 0f, 2f);
AddFloat(config2.barSpacing, 6f, 48f);
AddFloat(config2.healthBarYOffset, -64f, 64f);
AddFloat(config2.infectionBarYOffset, -64f, 64f);
AddFloat(config2.uiScale, 0.003f, 0.05f);
AddBool(config2.showHealthText);
AddBool(config2.showInfectionText);
AddEnum<ColorPreset>(config2.healthColor);
AddEnum<ColorPreset>(config2.infectionColor);
AddEnum<ColorPreset>(config2.backgroundColor);
AddEnum<InfectionBarDisplayMode>(config2.infectionDisplayMode);
AddConfigItem(CreateItem("LethalConfig.ConfigItems.GenericButtonConfigItem", "General", "Refresh all player bars", "Forces all visible player bars to refresh on the next update.", "Refresh", (Action)delegate
{
config2.NotifySettingsChanged();
}));
}
private static void AddBool(ConfigEntry<bool> entry)
{
AddConfigItem(CreateItem("LethalConfig.ConfigItems.BoolCheckBoxConfigItem", entry, CreateOptions("LethalConfig.ConfigItems.Options.BoolCheckBoxOptions", ("RequiresRestart", false))));
}
private static void AddFloat(ConfigEntry<float> entry, float min, float max)
{
AddConfigItem(CreateItem("LethalConfig.ConfigItems.FloatSliderConfigItem", entry, CreateOptions("LethalConfig.ConfigItems.Options.FloatSliderOptions", ("Min", min), ("Max", max), ("RequiresRestart", false))));
}
private static void AddEnum<T>(ConfigEntry<T> entry)
{
AddConfigItem(CreateItem(RequireType("LethalConfig.ConfigItems.EnumDropDownConfigItem`1").MakeGenericType(typeof(T)), entry, false));
}
private static object CreateOptions(string typeName, params (string Name, object Value)[] values)
{
object obj = Activator.CreateInstance(RequireType(typeName)) ?? throw new InvalidOperationException("Failed to create " + typeName + ".");
Type type = obj.GetType();
for (int i = 0; i < values.Length; i++)
{
(string Name, object Value) tuple = values[i];
string item = tuple.Name;
object item2 = tuple.Value;
PropertyInfo property = type.GetProperty(item, BindingFlags.Instance | BindingFlags.Public);
if (property == null || !property.CanWrite)
{
throw new MissingMemberException(type.FullName, item);
}
property.SetValue(obj, item2);
}
return obj;
}
private static object CreateItem(string typeName, params object[] args)
{
return CreateItem(RequireType(typeName), args);
}
private static object CreateItem(Type type, params object[] args)
{
return Activator.CreateInstance(type, args) ?? throw new InvalidOperationException("Failed to create " + type.FullName + ".");
}
private static void AddConfigItem(object configItem)
{
Type type = RequireType("LethalConfig.LethalConfigManager");
MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
foreach (MethodInfo methodInfo in methods)
{
ParameterInfo[] parameters = methodInfo.GetParameters();
if (methodInfo.Name == "AddConfigItem" && parameters.Length == 2 && parameters[0].ParameterType.IsInstanceOfType(configItem) && parameters[1].ParameterType == typeof(Assembly))
{
methodInfo.Invoke(null, new object[2]
{
configItem,
Assembly.GetExecutingAssembly()
});
return;
}
}
methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
foreach (MethodInfo methodInfo2 in methods)
{
ParameterInfo[] parameters2 = methodInfo2.GetParameters();
if (methodInfo2.Name == "AddConfigItem" && parameters2.Length == 1 && parameters2[0].ParameterType.IsInstanceOfType(configItem))
{
methodInfo2.Invoke(null, new object[1] { configItem });
return;
}
}
throw new MissingMethodException(type.FullName, "AddConfigItem");
}
private static Type RequireType(string typeName)
{
return Type.GetType(typeName + ", LethalConfig", throwOnError: false) ?? throw new TypeLoadException("Could not find optional LethalConfig type '" + typeName + "'.");
}
}
private readonly ConfigEntry<bool> enabled;
private readonly ConfigEntry<bool> hideInOrbit;
private readonly ConfigEntry<float> maxDistance;
private readonly ConfigEntry<float> headOffset;
private readonly ConfigEntry<float> barSpacing;
private readonly ConfigEntry<float> healthBarYOffset;
private readonly ConfigEntry<float> infectionBarYOffset;
private readonly ConfigEntry<float> uiScale;
private readonly ConfigEntry<bool> showHealthText;
private readonly ConfigEntry<bool> showInfectionText;
private readonly ConfigEntry<ColorPreset> healthColor;
private readonly ConfigEntry<ColorPreset> infectionColor;
private readonly ConfigEntry<ColorPreset> backgroundColor;
private readonly ConfigEntry<InfectionBarDisplayMode> infectionDisplayMode;
public bool Enabled => enabled.Value;
public float MaxDistance => maxDistance.Value;
public float HeadOffset => headOffset.Value;
public float BarSpacing => barSpacing.Value;
public float HealthBarYOffset => healthBarYOffset.Value;
public float InfectionBarYOffset => infectionBarYOffset.Value;
public float UiScale => uiScale.Value;
public bool HideInOrbit => hideInOrbit.Value;
public bool ShowHealthText => showHealthText.Value;
public bool ShowInfectionText => showInfectionText.Value;
public InfectionBarDisplayMode InfectionDisplayMode => infectionDisplayMode.Value;
public int Revision { get; private set; }
public event Action? SettingsChanged;
public static StatusBarConfig Create(ConfigFile configFile)
{
return new StatusBarConfig(configFile);
}
private StatusBarConfig(ConfigFile configFile)
{
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Expected O, but got Unknown
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Expected O, but got Unknown
//IL_00da: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Expected O, but got Unknown
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Expected O, but got Unknown
//IL_014c: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Expected O, but got Unknown
//IL_0185: Unknown result type (might be due to invalid IL or missing references)
//IL_018f: Expected O, but got Unknown
enabled = configFile.Bind<bool>("General", "Enabled", true, "Enable other player status bars.");
hideInOrbit = configFile.Bind<bool>("General", "Hide In Orbit", true, "Hide player status bars while the ship is still in orbit.");
maxDistance = configFile.Bind<float>("General", "Max Display Distance", 18f, new ConfigDescription("Hide other player status bars beyond this distance.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 80f), Array.Empty<object>()));
headOffset = configFile.Bind<float>("Layout", "Head Offset", 0.65f, new ConfigDescription("Vertical world-space offset above the player head anchor.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
barSpacing = configFile.Bind<float>("Layout", "Bar Spacing", 14f, new ConfigDescription("Vertical spacing between the health bar and infection bar.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(6f, 48f), Array.Empty<object>()));
healthBarYOffset = configFile.Bind<float>("Layout", "Health Bar Y Offset", 0f, new ConfigDescription("Local UI Y offset for the health bar.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-64f, 64f), Array.Empty<object>()));
infectionBarYOffset = configFile.Bind<float>("Layout", "Infection Bar Y Offset", 25f, new ConfigDescription("Local UI Y offset for the infection bar.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-64f, 64f), Array.Empty<object>()));
uiScale = configFile.Bind<float>("Layout", "UI Scale", 0.0085f, new ConfigDescription("World-space scale of the player status bar canvas.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.003f, 0.05f), Array.Empty<object>()));
showHealthText = configFile.Bind<bool>("Text", "Show Health Text", true, "Show health numbers on the health bar.");
showInfectionText = configFile.Bind<bool>("Text", "Show Infection Text", true, "Show infection percentage on the infection bar.");
healthColor = configFile.Bind<ColorPreset>("Colors", "Health Bar Color", ColorPreset.Green, "Fill color preset for the health bar.");
infectionColor = configFile.Bind<ColorPreset>("Colors", "Infection Bar Color", ColorPreset.Orange, "Fill color preset for the infection bar.");
backgroundColor = configFile.Bind<ColorPreset>("Colors", "Background Color", ColorPreset.Slate, "Background color preset for both bars.");
infectionDisplayMode = configFile.Bind<InfectionBarDisplayMode>("General", "Infection Bar Display Mode", InfectionBarDisplayMode.ShowOnlyWhenInfected, "Always show the infection bar, or only show it when infection is above zero.");
Subscribe<bool>(enabled);
Subscribe<bool>(hideInOrbit);
Subscribe<float>(maxDistance);
Subscribe<float>(headOffset);
Subscribe<float>(barSpacing);
Subscribe<float>(healthBarYOffset);
Subscribe<float>(infectionBarYOffset);
Subscribe<float>(uiScale);
Subscribe<bool>(showHealthText);
Subscribe<bool>(showInfectionText);
Subscribe<ColorPreset>(healthColor);
Subscribe<ColorPreset>(infectionColor);
Subscribe<ColorPreset>(backgroundColor);
Subscribe<InfectionBarDisplayMode>(infectionDisplayMode);
}
public Color GetHealthFillColor()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
return ResolveColor(healthColor.Value, 0.95f);
}
public Color GetInfectionFillColor()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
return ResolveColor(infectionColor.Value, 0.95f);
}
public Color GetBackgroundColor()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
return ResolveColor(backgroundColor.Value, 0.78f);
}
public Color GetBorderColor()
{
//IL_0001: 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)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
Color val = GetBackgroundColor();
val.a = 1f;
return Color.Lerp(val, Color.white, 0.35f);
}
private void Subscribe<T>(ConfigEntry<T> entry)
{
entry.SettingChanged += delegate
{
NotifySettingsChanged();
};
}
private void NotifySettingsChanged()
{
Revision++;
this.SettingsChanged?.Invoke();
}
private static Color ResolveColor(ColorPreset preset, float alpha)
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: 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)
//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_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: 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_00a9: 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_00c1: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_010b: Unknown result type (might be due to invalid IL or missing references)
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: Unknown result type (might be due to invalid IL or missing references)
Color result = (Color)(preset switch
{
ColorPreset.Green => new Color(0.18f, 0.86f, 0.32f, alpha),
ColorPreset.Red => new Color(0.88f, 0.25f, 0.22f, alpha),
ColorPreset.Orange => new Color(0.93f, 0.47f, 0.16f, alpha),
ColorPreset.Yellow => new Color(0.95f, 0.82f, 0.18f, alpha),
ColorPreset.Blue => new Color(0.28f, 0.58f, 0.92f, alpha),
ColorPreset.Cyan => new Color(0.18f, 0.83f, 0.88f, alpha),
ColorPreset.White => new Color(0.95f, 0.95f, 0.95f, alpha),
ColorPreset.Black => new Color(0.08f, 0.08f, 0.08f, alpha),
_ => new Color(0.12f, 0.15f, 0.2f, alpha),
});
result.a = alpha;
return result;
}
}
}
