using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HG;
using IL.RoR2;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using R2API.AutoVersionGen;
using R2API.ScriptableObjects;
using RoR2;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("R2API.Colors")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.3.0")]
[assembly: AssemblyInformationalVersion("1.0.3+e9ea73f05d82ba8fdebacfa23cfaf143584d236e")]
[assembly: AssemblyProduct("R2API.Colors")]
[assembly: AssemblyTitle("R2API.Colors")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.3.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 System.Diagnostics.CodeAnalysis
{
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
[ExcludeFromCodeCoverage]
[DebuggerNonUserCode]
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]
[DebuggerNonUserCode]
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;
}
}
}
namespace R2API
{
[AutoVersion]
public static class ColorsAPI
{
[CompilerGenerated]
private static class <>O
{
public static Manipulator <0>__ColorCatalogGetColorIL;
public static Manipulator <1>__ColorCatalogGetColorHexStringIL;
public static Manipulator <2>__GetColorIL;
public static Func<ColorIndex, Color32> <3>__ColorCatalogGetColor;
public static Func<ColorIndex, string> <4>__ColorCatalogGetColorHexString;
}
public const string PluginGUID = "com.bepis.r2api.colors";
public const string PluginName = "R2API.Colors";
private static List<SerializableDamageColor> addedSerializableDamageColors = new List<SerializableDamageColor>();
private static List<SerializableColorCatalogEntry> addedSerializableColors = new List<SerializableColorCatalogEntry>();
private static bool _hookEnabled = false;
public const string PluginVersion = "1.0.3";
[Obsolete("All submodules are automatically loaded and this property is now unused")]
public static bool Loaded => true;
internal static void SetHooks()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
//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_0043: Expected O, but got Unknown
//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_0063: Expected O, but got Unknown
if (!_hookEnabled)
{
object obj = <>O.<0>__ColorCatalogGetColorIL;
if (obj == null)
{
Manipulator val = ColorCatalogGetColorIL;
<>O.<0>__ColorCatalogGetColorIL = val;
obj = (object)val;
}
ColorCatalog.GetColor += (Manipulator)obj;
object obj2 = <>O.<1>__ColorCatalogGetColorHexStringIL;
if (obj2 == null)
{
Manipulator val2 = ColorCatalogGetColorHexStringIL;
<>O.<1>__ColorCatalogGetColorHexStringIL = val2;
obj2 = (object)val2;
}
ColorCatalog.GetColorHexString += (Manipulator)obj2;
object obj3 = <>O.<2>__GetColorIL;
if (obj3 == null)
{
Manipulator val3 = GetColorIL;
<>O.<2>__GetColorIL = val3;
obj3 = (object)val3;
}
DamageColor.FindColor += (Manipulator)obj3;
_hookEnabled = true;
}
}
internal static void UnsetHooks()
{
//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: Expected O, but got Unknown
//IL_0030: 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_003b: Expected O, but got Unknown
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Expected O, but got Unknown
object obj = <>O.<0>__ColorCatalogGetColorIL;
if (obj == null)
{
Manipulator val = ColorCatalogGetColorIL;
<>O.<0>__ColorCatalogGetColorIL = val;
obj = (object)val;
}
ColorCatalog.GetColor -= (Manipulator)obj;
object obj2 = <>O.<1>__ColorCatalogGetColorHexStringIL;
if (obj2 == null)
{
Manipulator val2 = ColorCatalogGetColorHexStringIL;
<>O.<1>__ColorCatalogGetColorHexStringIL = val2;
obj2 = (object)val2;
}
ColorCatalog.GetColorHexString -= (Manipulator)obj2;
object obj3 = <>O.<2>__GetColorIL;
if (obj3 == null)
{
Manipulator val3 = GetColorIL;
<>O.<2>__GetColorIL = val3;
obj3 = (object)val3;
}
DamageColor.FindColor -= (Manipulator)obj3;
_hookEnabled = false;
}
private static void GetColorIL(ILContext il)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: 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_009b: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
FieldReference arrayToGetLength = null;
val.GotoNext(new Func<Instruction, bool>[1]
{
(Instruction inst) => ILPatternMatchingExt.MatchLdsfld(inst, ref arrayToGetLength)
});
val.GotoPrev((MoveType)2, new Func<Instruction, bool>[1]
{
(Instruction inst) => ILPatternMatchingExt.MatchLdarg(inst, 0)
});
val.Emit(OpCodes.Ldsfld, arrayToGetLength);
val.Emit(OpCodes.Ldlen);
val.Emit(OpCodes.Conv_I4);
int index = val.Index;
val.Index = index + 1;
val.Emit(OpCodes.Pop);
}
private static void ColorCatalogGetColorIL(ILContext il)
{
//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_0007: 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_0034: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
val.Emit(OpCodes.Ldarg_0);
val.EmitDelegate<Func<ColorIndex, Color32>>((Func<ColorIndex, Color32>)ColorCatalogGetColor);
val.Emit(OpCodes.Ret);
}
private static Color32 ColorCatalogGetColor(ColorIndex colorIndex)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Expected I4, but got Unknown
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
int num = (int)colorIndex;
if (num < 0 || num > GetLength(ref ColorCatalog.indexToColor32))
{
num = 14;
}
return GetItem(ref ColorCatalog.indexToColor32, num);
}
private static void ColorCatalogGetColorHexStringIL(ILContext il)
{
//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_0007: 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_0034: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
val.Emit(OpCodes.Ldarg_0);
val.EmitDelegate<Func<ColorIndex, string>>((Func<ColorIndex, string>)ColorCatalogGetColorHexString);
val.Emit(OpCodes.Ret);
}
private static string ColorCatalogGetColorHexString(ColorIndex colorIndex)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Expected I4, but got Unknown
int num = (int)colorIndex;
if (num < 0 || num > GetLength(ref ColorCatalog.indexToHexString))
{
num = 14;
}
return GetItem(ref ColorCatalog.indexToHexString, num);
}
public static DamageColorIndex RegisterDamageColor(Color color)
{
SetHooks();
byte num = (byte)DamageColor.colors.Length;
ArrayUtils.ArrayAppend<Color>(ref DamageColor.colors, ref color);
return (DamageColorIndex)num;
}
public static void AddSerializableDamageColor(SerializableDamageColor serializableDamageColor)
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
SetHooks();
if (addedSerializableDamageColors.Contains(serializableDamageColor))
{
ColorsPlugin.Logger.LogError((object)$"Attempted to add SerializableDamageColor {serializableDamageColor} twice! aborting.");
}
else
{
serializableDamageColor.DamageColorIndex = RegisterDamageColor(serializableDamageColor.color);
}
}
public static ColorIndex RegisterColor(Color color)
{
//IL_0014: 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_001a: 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)
SetHooks();
int length = GetLength(ref ColorCatalog.indexToColor32);
Color32 val = Color32.op_Implicit(color);
ArrayUtils.ArrayAppend<Color32>(ref ColorCatalog.indexToColor32, ref val);
string text = Util.RGBToHex(Color32.op_Implicit(color));
ArrayUtils.ArrayAppend<string>(ref ColorCatalog.indexToHexString, ref text);
return (ColorIndex)length;
}
public static void AddSerializableColor(SerializableColorCatalogEntry serializableColor)
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: 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)
SetHooks();
if (addedSerializableColors.Contains(serializableColor))
{
ColorsPlugin.Logger.LogError((object)$"Attempted to add SerializableColor {serializableColor} twice! aborting.");
}
else
{
serializableColor.ColorIndex = RegisterColor(Color32.op_Implicit(serializableColor.color32));
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static int GetLength<T>(ref T[] array)
{
return array.Length;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static T GetItem<T>(ref T[] array, int i)
{
return array[i];
}
}
[BepInPlugin("com.bepis.r2api.colors", "R2API.Colors", "1.0.3")]
public sealed class ColorsPlugin : BaseUnityPlugin
{
internal static ManualLogSource Logger { get; set; }
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
}
private void OnDestroy()
{
ColorsAPI.UnsetHooks();
}
}
}
namespace R2API.AutoVersionGen
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
internal class AutoVersionAttribute : Attribute
{
}
}
namespace R2API.ScriptableObjects
{
[CreateAssetMenu(fileName = "New ColorCatalogEntry", menuName = "R2API/Colors/ColorCatalogEntry")]
public class SerializableColorCatalogEntry : ScriptableObject
{
public Color32 color32;
public ColorIndex ColorIndex { get; internal set; } = (ColorIndex)(-1);
}
[CreateAssetMenu(fileName = "New DamageColor", menuName = "R2API/Colors/DamageColor")]
public class SerializableDamageColor : ScriptableObject
{
public Color color;
public DamageColorIndex DamageColorIndex { get; internal set; }
}
}
