using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
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("ArceDev.NativeStatusUI")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.1.0")]
[assembly: AssemblyInformationalVersion("0.2.1")]
[assembly: AssemblyProduct("ArceDev.NativeStatusUI")]
[assembly: AssemblyTitle("NativeStatusUI")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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]
[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]
[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 BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
[Embedded]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
[Embedded]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace Microsoft.CodeAnalysis
{
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace NativeStatusUI
{
public static class NativeStatus
{
private static readonly Dictionary<string, StatusDefinition> Definitions = new Dictionary<string, StatusDefinition>(StringComparer.Ordinal);
private static readonly List<string> Order = new List<string>();
private static NativeStatusHost? _host;
public static void Register(string id, byte[] png, Color color)
{
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
if (string.IsNullOrWhiteSpace(id))
{
throw new ArgumentException("A status identifier is required.", "id");
}
if (png == null || png.Length == 0)
{
throw new ArgumentException("A PNG mask is required.", "png");
}
if (Definitions.ContainsKey(id))
{
throw new InvalidOperationException("Native status '" + id + "' is already registered.");
}
StatusDefinition statusDefinition = new StatusDefinition(id, (byte[])png.Clone(), color);
Definitions.Add(id, statusDefinition);
Order.Add(id);
_host?.Add(statusDefinition);
}
public static void Activate(string id, float durationSeconds)
{
if (!Definitions.TryGetValue(id, out StatusDefinition value))
{
throw new KeyNotFoundException("Native status '" + id + "' is not registered.");
}
if (durationSeconds <= 0f)
{
throw new ArgumentOutOfRangeException("durationSeconds", "Duration must be positive.");
}
value.Duration = durationSeconds;
value.ExpiresAt = Time.time + durationSeconds;
}
public static void Hide(string id)
{
if (Definitions.TryGetValue(id, out StatusDefinition value))
{
value.Duration = 0f;
value.ExpiresAt = 0f;
}
}
internal static void Attach(CanvasGroup poisonGroup, CanvasGroup fireGroup, Image fireImage, Image firePercent, Image firePercentLerped)
{
NativeStatusHost nativeStatusHost = ((Component)fireGroup).gameObject.AddComponent<NativeStatusHost>();
nativeStatusHost.Initialize(poisonGroup, fireGroup, fireImage, firePercent, firePercentLerped);
_host = nativeStatusHost;
foreach (string item in Order)
{
nativeStatusHost.Add(Definitions[item]);
}
}
internal static float GetPercent(StatusDefinition definition, float now)
{
return CalculatePercent(definition.Duration, definition.ExpiresAt, now);
}
internal static void Detach(NativeStatusHost host)
{
if ((Object)(object)_host == (Object)(object)host)
{
_host = null;
}
}
internal static void Validate()
{
if (CalculatePercent(60f, 60f, 30f) != 0.5f || CalculatePercent(0f, 60f, 30f) != 0f || CalculatePercent(60f, 30f, 60f) != 0f)
{
throw new InvalidOperationException("NativeStatusUI duration validation failed.");
}
}
private static float CalculatePercent(float duration, float expiresAt, float now)
{
if (!(duration > 0f))
{
return 0f;
}
return Mathf.Clamp01((expiresAt - now) / duration);
}
}
internal sealed class StatusDefinition
{
internal string Id { get; }
internal byte[] Png { get; }
internal Color Color { get; }
internal float Duration { get; set; }
internal float ExpiresAt { get; set; }
internal StatusDefinition(string id, byte[] png, Color color)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
Id = id;
Png = png;
Color = color;
}
}
internal sealed class NativeStatusHost : MonoBehaviour
{
private readonly List<StatusView> _views = new List<StatusView>();
private CanvasGroup _fireGroup;
private Image _fireImage;
private Image _firePercent;
private Image _firePercentLerped;
private RectTransform _fireRect;
private Vector2 _spacing;
internal void Initialize(CanvasGroup poisonGroup, CanvasGroup fireGroup, Image fireImage, Image firePercent, Image firePercentLerped)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
//IL_0042: 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_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
_fireGroup = fireGroup;
_fireImage = fireImage;
_firePercent = firePercent;
_firePercentLerped = firePercentLerped;
RectTransform val = (RectTransform)((Component)poisonGroup).transform;
_fireRect = (RectTransform)((Component)fireGroup).transform;
_spacing = _fireRect.anchoredPosition - val.anchoredPosition;
}
internal void Add(StatusDefinition definition)
{
_views.Add(StatusView.Create(definition, _fireGroup, _fireImage, _firePercent, _firePercentLerped));
}
private void Update()
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
float time = Time.time;
int num = 0;
foreach (StatusView view in _views)
{
if (view.SetPercent(NativeStatus.GetPercent(view.Definition, time)))
{
view.Rect.anchoredPosition = _fireRect.anchoredPosition + _spacing * (float)(++num);
}
}
}
private void OnDestroy()
{
NativeStatus.Detach(this);
foreach (StatusView view in _views)
{
view.Dispose();
}
}
}
internal sealed class StatusView : IDisposable
{
private readonly GameObject _root;
private readonly CanvasGroup _group;
private readonly Image _percent;
private readonly Image _percentLerped;
private readonly Sprite _sprite;
private readonly Texture2D _texture;
internal StatusDefinition Definition { get; }
internal RectTransform Rect { get; }
private StatusView(StatusDefinition definition, GameObject root, CanvasGroup group, Image percent, Image percentLerped, Sprite sprite, Texture2D texture)
{
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Expected O, but got Unknown
Definition = definition;
_root = root;
_group = group;
_percent = percent;
_percentLerped = percentLerped;
_sprite = sprite;
_texture = texture;
Rect = (RectTransform)root.transform;
}
internal static StatusView Create(StatusDefinition definition, CanvasGroup fireGroup, Image fireImage, Image firePercent, Image firePercentLerped)
{
//IL_0055: 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_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Expected O, but got Unknown
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
GameObject val = Object.Instantiate<GameObject>(((Component)fireGroup).gameObject, ((Component)fireGroup).transform.parent);
((Object)val).name = definition.Id;
Image[] componentsInChildren = ((Component)fireGroup).GetComponentsInChildren<Image>(true);
Image[] componentsInChildren2 = val.GetComponentsInChildren<Image>(true);
Image val2 = FindClone(fireImage, componentsInChildren, componentsInChildren2);
Image val3 = FindClone(firePercent, componentsInChildren, componentsInChildren2);
Image val4 = FindClone(firePercentLerped, componentsInChildren, componentsInChildren2);
Texture2D val5 = new Texture2D(2, 2, (TextureFormat)4, false)
{
name = definition.Id,
wrapMode = (TextureWrapMode)1
};
if (!ImageConversion.LoadImage(val5, definition.Png, true))
{
Object.Destroy((Object)(object)val);
Object.Destroy((Object)(object)val5);
throw new InvalidOperationException("Native status '" + definition.Id + "' does not contain a valid PNG.");
}
Sprite sprite = (val2.sprite = Sprite.Create(val5, new Rect(0f, 0f, (float)((Texture)val5).width, (float)((Texture)val5).height), new Vector2(0.5f, 0.5f), 100f));
((Graphic)val2).material = ((Graphic)fireImage).material;
((Graphic)val2).color = definition.Color;
val2.preserveAspect = true;
((Graphic)val3).color = definition.Color;
((Graphic)val4).color = definition.Color;
CanvasGroup component = val.GetComponent<CanvasGroup>();
component.alpha = 0f;
return new StatusView(definition, val, component, val3, val4, sprite, val5);
}
internal bool SetPercent(float percent)
{
bool flag = percent > 0f;
_group.alpha = (flag ? 1f : 0f);
_percent.fillAmount = percent;
_percentLerped.fillAmount = percent;
return flag;
}
public void Dispose()
{
if (Object.op_Implicit((Object)(object)_root))
{
Object.Destroy((Object)(object)_root);
}
Object.Destroy((Object)(object)_sprite);
Object.Destroy((Object)(object)_texture);
}
private static Image FindClone(Image source, Image[] sourceImages, Image[] clonedImages)
{
int num = Array.IndexOf(sourceImages, source);
if (num < 0 || num >= clonedImages.Length)
{
throw new InvalidOperationException("The native vitals UI hierarchy has changed.");
}
return clonedImages[num];
}
}
[BepInPlugin("ArceDev.NativeStatusUI", "NativeStatusUI", "0.2.1")]
public class Plugin : BaseUnityPlugin
{
[HarmonyPatch(typeof(VitalsUI), "Awake")]
private static class VitalsUiPatch
{
private static void Postfix(CanvasGroup ____poisonGroup, CanvasGroup ____fireGroup, Image ____fireImage, Image ____firePercent, Image ____firePercentLerped)
{
NativeStatus.Attach(____poisonGroup, ____fireGroup, ____fireImage, ____firePercent, ____firePercentLerped);
}
}
public const string Id = "ArceDev.NativeStatusUI";
internal static ManualLogSource Log { get; private set; }
public static string Name => "NativeStatusUI";
public static string Version => "0.2.1";
private void Awake()
{
Log = ((BaseUnityPlugin)this).Logger;
NativeStatus.Validate();
Harmony.CreateAndPatchAll(typeof(Plugin).Assembly, "ArceDev.NativeStatusUI");
Log.LogInfo((object)("Plugin " + Name + " is loaded!"));
}
}
}
namespace System.Diagnostics.CodeAnalysis
{
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class ConstantExpectedAttribute : Attribute
{
public object? Min { get; set; }
public object? Max { get; set; }
}
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class ExperimentalAttribute : Attribute
{
public string DiagnosticId { get; }
public string? UrlFormat { get; set; }
public ExperimentalAttribute(string diagnosticId)
{
DiagnosticId = diagnosticId;
}
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
[ExcludeFromCodeCoverage]
internal sealed class MemberNotNullAttribute : Attribute
{
public string[] Members { get; }
public MemberNotNullAttribute(string member)
{
Members = new string[1] { member };
}
public MemberNotNullAttribute(params string[] members)
{
Members = members;
}
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
[ExcludeFromCodeCoverage]
internal sealed class MemberNotNullWhenAttribute : Attribute
{
public bool ReturnValue { get; }
public string[] Members { get; }
public MemberNotNullWhenAttribute(bool returnValue, string member)
{
ReturnValue = returnValue;
Members = new string[1] { member };
}
public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
{
ReturnValue = returnValue;
Members = members;
}
}
[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class SetsRequiredMembersAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class StringSyntaxAttribute : Attribute
{
public const string CompositeFormat = "CompositeFormat";
public const string DateOnlyFormat = "DateOnlyFormat";
public const string DateTimeFormat = "DateTimeFormat";
public const string EnumFormat = "EnumFormat";
public const string GuidFormat = "GuidFormat";
public const string Json = "Json";
public const string NumericFormat = "NumericFormat";
public const string Regex = "Regex";
public const string TimeOnlyFormat = "TimeOnlyFormat";
public const string TimeSpanFormat = "TimeSpanFormat";
public const string Uri = "Uri";
public const string Xml = "Xml";
public string Syntax { get; }
public object?[] Arguments { get; }
public StringSyntaxAttribute(string syntax)
{
Syntax = syntax;
Arguments = new object[0];
}
public StringSyntaxAttribute(string syntax, params object?[] arguments)
{
Syntax = syntax;
Arguments = arguments;
}
}
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class UnscopedRefAttribute : Attribute
{
}
}
namespace System.Runtime.Versioning
{
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class RequiresPreviewFeaturesAttribute : Attribute
{
public string? Message { get; }
public string? Url { get; set; }
public RequiresPreviewFeaturesAttribute()
{
}
public RequiresPreviewFeaturesAttribute(string? message)
{
Message = message;
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class CallerArgumentExpressionAttribute : Attribute
{
public string ParameterName { get; }
public CallerArgumentExpressionAttribute(string parameterName)
{
ParameterName = parameterName;
}
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class CollectionBuilderAttribute : Attribute
{
public Type BuilderType { get; }
public string MethodName { get; }
public CollectionBuilderAttribute(Type builderType, string methodName)
{
BuilderType = builderType;
MethodName = methodName;
}
}
[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class CompilerFeatureRequiredAttribute : Attribute
{
public const string RefStructs = "RefStructs";
public const string RequiredMembers = "RequiredMembers";
public string FeatureName { get; }
public bool IsOptional { get; set; }
public CompilerFeatureRequiredAttribute(string featureName)
{
FeatureName = featureName;
}
}
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
{
public string[] Arguments { get; }
public InterpolatedStringHandlerArgumentAttribute(string argument)
{
Arguments = new string[1] { argument };
}
public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
{
Arguments = arguments;
}
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class InterpolatedStringHandlerAttribute : Attribute
{
}
[EditorBrowsable(EditorBrowsableState.Never)]
[ExcludeFromCodeCoverage]
internal static class IsExternalInit
{
}
[AttributeUsage(AttributeTargets.Method, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class ModuleInitializerAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class OverloadResolutionPriorityAttribute : Attribute
{
public int Priority { get; }
public OverloadResolutionPriorityAttribute(int priority)
{
Priority = priority;
}
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
[ExcludeFromCodeCoverage]
internal sealed class ParamCollectionAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class RequiredMemberAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
[EditorBrowsable(EditorBrowsableState.Never)]
[ExcludeFromCodeCoverage]
internal sealed class RequiresLocationAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
[ExcludeFromCodeCoverage]
internal sealed class SkipLocalsInitAttribute : Attribute
{
}
}
