using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
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 Dolso;
using HG.Reflection;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.UI;
using TMPro;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("PingChat")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("PingChat")]
[assembly: AssemblyTitle("PingChat")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Dolso
{
internal static class log
{
private static readonly ManualLogSource logger = Logger.CreateLogSource(Assembly.GetExecutingAssembly().GetName().Name);
[Conditional("DEBUG")]
internal static void debug(object data)
{
logger.LogDebug(data);
}
internal static void info(object data)
{
logger.LogInfo(data);
}
internal static void message(object data)
{
logger.LogMessage(data);
}
internal static void warning(object data)
{
logger.LogWarning(data);
}
internal static void error(object data)
{
logger.LogError(data);
}
internal static void fatal(object data)
{
logger.LogFatal(data);
}
internal static void LogError(this ILCursor c, object data)
{
logger.LogError((object)$"ILCursor failure, skipping: {data}\n{c}");
}
internal static void LogErrorCaller(this ILCursor c, object data)
{
logger.LogError((object)$"ILCursor failed in {new StackFrame(1).GetMethod().Name}, skipping: {data}\n{c}");
}
}
internal static class HookManager
{
internal delegate bool ConfigEnabled<T>(T configValue);
private class HookedConfig<T>
{
private readonly ConfigEnabled<T> enabled;
private readonly IDetour detour;
internal HookedConfig(ConfigEntry<T> configEntry, ConfigEnabled<T> enabled, IDetour detour)
{
this.enabled = enabled;
this.detour = detour;
if (configEntry != null)
{
configEntry.SettingChanged += ConfigChanged;
ConfigChanged(configEntry, null);
}
else
{
detour.Apply();
}
}
private void ConfigChanged(object sender, EventArgs args)
{
if (enabled(((ConfigEntry<T>)sender).Value))
{
if (!detour.IsApplied)
{
detour.Apply();
}
}
else if (detour.IsApplied)
{
detour.Undo();
}
}
}
internal const BindingFlags allFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
private static readonly ConfigEnabled<bool> boolConfigEnabled = BoolEnabled;
private static ILHookConfig ilHookConfig = new ILHookConfig
{
ManualApply = true
};
private static HookConfig onHookConfig = new HookConfig
{
ManualApply = true
};
internal static void Hook(Type typeFrom, string fromMethod, Manipulator ilHook)
{
Hook(GetMethod(typeFrom, fromMethod), ilHook);
}
internal static void Hook(Delegate fromMethod, Manipulator ilHook)
{
Hook(fromMethod.Method, ilHook);
}
internal static void Hook(MethodBase fromMethod, Manipulator ilHook)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
try
{
new ILHook(fromMethod, ilHook, ref ilHookConfig).Apply();
}
catch (Exception e)
{
e.LogHookError(fromMethod, ((Delegate)(object)ilHook).Method);
}
}
internal static void Hook(Type typeFrom, string fromMethod, Delegate onHook)
{
Hook(GetMethod(typeFrom, fromMethod), onHook.Method, onHook.Target);
}
internal static void Hook(Delegate fromMethod, Delegate onHook)
{
Hook(fromMethod.Method, onHook.Method, onHook.Target);
}
internal static void Hook(MethodBase fromMethod, Delegate onHook)
{
Hook(fromMethod, onHook.Method, onHook.Target);
}
internal static void Hook(MethodBase fromMethod, MethodInfo onHook, object target = null)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
try
{
new Hook(fromMethod, onHook, target, ref onHookConfig).Apply();
}
catch (Exception e)
{
e.LogHookError(fromMethod, onHook);
}
}
internal static void HookConfig(this ConfigEntry<bool> configEntry, Type typeFrom, string fromMethod, Delegate hook)
{
configEntry.HookConfig(boolConfigEnabled, GetMethod(typeFrom, fromMethod), hook.Method, hook.Target);
}
internal static void HookConfig(this ConfigEntry<bool> configEntry, MethodBase fromMethod, Delegate hook)
{
configEntry.HookConfig(boolConfigEnabled, fromMethod, hook.Method, hook.Target);
}
internal static void HookConfig(this ConfigEntry<bool> configEntry, MethodBase fromMethod, MethodInfo hook)
{
configEntry.HookConfig(boolConfigEnabled, fromMethod, hook);
}
internal static void HookConfig<T>(this ConfigEntry<T> configEntry, ConfigEnabled<T> enabled, Type typeFrom, string fromMethod, Delegate hook)
{
configEntry.HookConfig(enabled, GetMethod(typeFrom, fromMethod), hook.Method, hook.Target);
}
internal static void HookConfig<T>(this ConfigEntry<T> configEntry, ConfigEnabled<T> enabled, MethodBase fromMethod, Delegate hook)
{
configEntry.HookConfig(enabled, fromMethod, hook.Method, hook.Target);
}
internal static void HookConfig<T>(this ConfigEntry<T> configEntry, ConfigEnabled<T> enabled, MethodBase fromMethod, MethodInfo hook, object target = null)
{
try
{
new HookedConfig<T>(configEntry, enabled, ManualDetour(fromMethod, hook, target));
}
catch (Exception e)
{
e.LogHookError(fromMethod, hook);
}
}
internal static IDetour ManualDetour(Type typeFrom, string fromMethod, Delegate hook)
{
return ManualDetour(GetMethod(typeFrom, fromMethod), hook.Method, hook.Target);
}
internal static IDetour ManualDetour(MethodBase fromMethod, Delegate hook)
{
return ManualDetour(fromMethod, hook.Method, hook.Target);
}
internal static IDetour ManualDetour(MethodBase fromMethod, MethodInfo hook, object target = null)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Expected O, but got Unknown
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Expected O, but got Unknown
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
try
{
ParameterInfo[] parameters = hook.GetParameters();
if (parameters.Length == 1 && parameters[0].ParameterType == typeof(ILContext))
{
return (IDetour)new ILHook(fromMethod, (Manipulator)hook.CreateDelegate(typeof(Manipulator)), ref ilHookConfig);
}
return (IDetour)new Hook(fromMethod, hook, target, ref onHookConfig);
}
catch (Exception e)
{
e.LogHookError(fromMethod, hook);
return null;
}
}
internal static MethodInfo GetMethod(Type typeFrom, string methodName)
{
if (typeFrom == null || methodName == null)
{
log.error($"Null argument in GetMethod: type={typeFrom}, name={methodName}");
return null;
}
MethodInfo[] array = (from a in typeFrom.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
where a.Name == methodName
select a).ToArray();
switch (array.Length)
{
case 1:
return array[0];
case 0:
log.error($"Failed to find method: {typeFrom}::{methodName}");
return null;
default:
{
string text = $"{array.Length} ambiguous matches found for: {typeFrom}::{methodName}, may be incorrect";
MethodInfo[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
text = text + "\n" + array2[i];
}
log.warning(text);
return array[0];
}
}
}
internal static MethodInfo GetMethod(Type typeFrom, string methodName, params Type[] parameters)
{
if (typeFrom == null || methodName == null)
{
log.error($"Null argument in GetMethod: type={typeFrom}, name={methodName}");
return null;
}
MethodInfo? method = typeFrom.GetMethod(methodName, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, parameters, null);
if (method == null)
{
log.error($"Failed to find method: {typeFrom}::{methodName}_{parameters.Length}");
}
return method;
}
internal static void SetPriority(string[] before_il = null, string[] before_on = null, string[] after_il = null, string[] after_on = null)
{
ilHookConfig.Before = before_il;
onHookConfig.Before = before_on;
ilHookConfig.After = after_il;
onHookConfig.After = after_on;
}
internal static void LogHookError(this Exception e, MethodBase fromMethod, MethodInfo hook)
{
log.error((fromMethod == null) ? $"null from-method for hook: {hook.Name}\n{e}" : $"Failed to hook: {fromMethod.DeclaringType}::{fromMethod.Name} - {hook.Name}\n{e}");
}
private static bool BoolEnabled(bool configValue)
{
return configValue;
}
}
internal static class RiskofOptions
{
internal const string RooGuid = "com.rune580.riskofoptions";
internal static bool enabled => Chainloader.PluginInfos.ContainsKey("com.rune580.riskofoptions");
[MethodImpl(MethodImplOptions.NoInlining)]
internal static void SetSprite(Sprite sprite)
{
ModSettingsManager.SetModIcon(sprite);
}
internal static void SetSpriteDefaultIcon()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
//IL_005b: 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)
try
{
string fullName = new DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)).FullName;
Texture2D val = new Texture2D(256, 256);
if (ImageConversion.LoadImage(val, File.ReadAllBytes(Path.Combine(fullName, "icon.png"))))
{
ModSettingsManager.SetModIcon(Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f)));
}
else
{
log.error("Failed to load icon.png");
}
}
catch (Exception ex)
{
log.error("Failed to load icon.png\n" + ex);
}
}
internal static void AddOption(ConfigEntryBase entry)
{
AddOption(entry, string.Empty, string.Empty);
}
[MethodImpl(MethodImplOptions.NoInlining)]
internal static void AddOption(ConfigEntryBase entry, string categoryName = "", string name = "", bool restartRequired = false)
{
//IL_0157: Unknown result type (might be due to invalid IL or missing references)
//IL_015c: Unknown result type (might be due to invalid IL or missing references)
//IL_0177: Unknown result type (might be due to invalid IL or missing references)
//IL_0192: Unknown result type (might be due to invalid IL or missing references)
//IL_019d: Unknown result type (might be due to invalid IL or missing references)
//IL_01b3: Expected O, but got Unknown
//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
//IL_0129: 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_0139: Expected O, but got Unknown
//IL_0139: Unknown result type (might be due to invalid IL or missing references)
//IL_014f: Expected O, but got Unknown
//IL_014a: Unknown result type (might be due to invalid IL or missing references)
//IL_00f4: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Expected O, but got Unknown
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_01b4: Expected O, but got Unknown
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Expected O, but got Unknown
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Expected O, but got Unknown
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Expected O, but got Unknown
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Expected O, but got Unknown
//IL_00a5: 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_0095: Expected O, but got Unknown
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
Type settingType = entry.SettingType;
object obj;
if (!(settingType == typeof(float)))
{
obj = ((!(settingType == typeof(string))) ? ((!(settingType == typeof(bool))) ? ((!(settingType == typeof(int))) ? ((!(settingType == typeof(Color))) ? ((!(settingType == typeof(KeyboardShortcut))) ? ((object)((!settingType.IsEnum) ? ((ChoiceOption)null) : new ChoiceOption(entry, new ChoiceConfig()))) : ((object)new KeyBindOption((ConfigEntry<KeyboardShortcut>)(object)entry, new KeyBindConfig()))) : ((object)new ColorOption((ConfigEntry<Color>)(object)entry, new ColorOptionConfig()))) : ((object)new IntFieldOption((ConfigEntry<int>)(object)entry, new IntFieldConfig()))) : ((object)new CheckBoxOption((ConfigEntry<bool>)(object)entry, new CheckBoxConfig()))) : ((object)new StringInputFieldOption((ConfigEntry<string>)(object)entry, new InputFieldConfig
{
submitOn = (SubmitEnum)6,
lineType = (LineType)0
})));
}
else if (entry.Description.AcceptableValues is AcceptableValueRange<float>)
{
obj = (object)new SliderOption((ConfigEntry<float>)(object)entry, new SliderConfig
{
min = ((AcceptableValueRange<float>)(object)entry.Description.AcceptableValues).MinValue,
max = ((AcceptableValueRange<float>)(object)entry.Description.AcceptableValues).MaxValue,
FormatString = "{0:f2}",
description = entry.DescWithDefault("{0:f2}")
});
}
else
{
ConfigEntry<float> obj2 = (ConfigEntry<float>)(object)entry;
FloatFieldConfig val = new FloatFieldConfig();
((NumericFieldConfig<float>)val).FormatString = "{0:f2}";
((BaseOptionConfig)val).description = entry.DescWithDefault("{0:f2}");
obj = (object)new FloatFieldOption(obj2, val);
}
BaseOption val2 = (BaseOption)obj;
if (val2 == null)
{
return;
}
BaseOptionConfig config = val2.GetConfig();
config.category = categoryName;
config.name = name;
config.restartRequired = restartRequired;
if (config.description == "")
{
config.description = entry.DescWithDefault();
}
try
{
ModSettingsManager.AddOption(val2);
}
catch (Exception arg)
{
log.error($"AddOption {entry.Definition} failed\n{arg}");
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
internal static void AddOption(ConfigEntry<float> entry, float min, float max, string format = "{0:f2}", string categoryName = "")
{
//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_000d: 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_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Expected O, but got Unknown
ModSettingsManager.AddOption((BaseOption)new SliderOption(entry, new SliderConfig
{
min = min,
max = max,
FormatString = format,
category = categoryName,
description = ((ConfigEntryBase)(object)entry).DescWithDefault(format)
}));
}
[MethodImpl(MethodImplOptions.NoInlining)]
internal static void AddIntSlider(ConfigEntry<int> entry, int min, int max, string categoryName = "")
{
//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_000d: 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_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
ModSettingsManager.AddOption((BaseOption)new IntSliderOption(entry, new IntSliderConfig
{
min = min,
max = max,
category = categoryName,
description = ((ConfigEntryBase)(object)entry).DescWithDefault()
}));
}
private static string DescWithDefault(this ConfigEntryBase entry, string format = "{0}")
{
return string.Format("{1}\n[Default: " + format + "]", entry.DefaultValue, entry.Description.Description);
}
}
}
namespace PingChat
{
internal static class Config
{
internal static ConfigFile configFile;
internal static ConfigEntry<KeyboardShortcut> chatKey;
internal static ConfigEntry<float> itemScale;
internal static ConfigEntry<float> moveDuration;
internal static ConfigEntry<float> interactDuration;
internal static ConfigEntry<float> itemDuration;
internal static ConfigEntry<float> enemyDuration;
internal static ConfigEntry<bool> chatToggle;
internal static ConfigEntry<bool> itemIconToggle;
internal static ConfigEntry<bool> shopItemIconToggle;
internal static ConfigEntry<bool> enemyIconToggle;
internal static ConfigEntry<bool> enemyIconColorToggle;
internal static Dictionary<EliteDef, ConfigEntry<Color>> elite_colors = new Dictionary<EliteDef, ConfigEntry<Color>>();
internal static ConfigEntry<Color> not_elite_color;
internal static ConfigEntry<Color> itemIconColor;
internal static ConfigEntry<Color> interactableIconColor;
internal static ConfigEntry<string> attack_message;
internal static ConfigEntry<string> pickup_message;
internal static ConfigEntry<string> teleporter_message;
internal static ConfigEntry<string> potential_message;
internal static ConfigEntry<string> shop_message;
internal static ConfigEntry<string> other_message;
internal static void DoConfigs(ConfigFile configFile)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_016b: Unknown result type (might be due to invalid IL or missing references)
//IL_0199: Unknown result type (might be due to invalid IL or missing references)
//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
Config.configFile = configFile;
chatKey = configFile.Bind<KeyboardShortcut>("Misc", "Key", new KeyboardShortcut((KeyCode)282, Array.Empty<KeyCode>()), "The key for sending a custom chat message");
itemScale = configFile.Bind<float>("Misc", "Item icon scale", 0.67f, "Scale of item icon in pings");
moveDuration = configFile.Bind<float>("Durations", "Move ping duration", 6f, "Duration of move here ping");
interactDuration = configFile.Bind<float>("Durations", "Interactives ping duration", 30f, "Duration of interactives ping. Includes chests, shops, printers, teleporter, etc");
itemDuration = configFile.Bind<float>("Durations", "Item ping duration", 60f, "Duration of item ping. Includes scrappers and potentials");
enemyDuration = configFile.Bind<float>("Durations", "Enemy ping duration", 8f, "Duration of attack enemy ping");
chatToggle = configFile.Bind<bool>("Toggles", "Chat coloring toggle", true, "Toggles the coloring of chat");
enemyIconToggle = configFile.Bind<bool>("Toggles", "Enemy icon toggle", true, "Toggles changing the ping icons for enemies to their logbook icons");
enemyIconColorToggle = configFile.Bind<bool>("Toggles", "Elite enemy icon coloring toggle", true, "Toggles the coloring of elite enemy ping icons. If false, but icons are on, will use color of 'None'");
itemIconToggle = configFile.Bind<bool>("Toggles", "Item icon toggle", true, "Toggles changing the ping icons for items to their logbook icons");
shopItemIconToggle = configFile.Bind<bool>("Toggles", "Item icon toggle for multishops and printers", true, "Toggles changing the ping icons for items in multishops and printers");
itemIconColor = configFile.Bind<Color>("IColor", "Item icon color", new Color(1f, 1f, 1f), "Color of pinged item icons");
interactableIconColor = configFile.Bind<Color>("IColor", "Pinged interactable color", new Color(0.89f, 0.87f, 0.17f), "Color of pinged interactables");
not_elite_color = configFile.Bind<Color>("Elite colors", "None", new Color(1f, 1f, 1f), "Color hex: (Red, Green, Blue, Alpha)");
attack_message = configFile.Bind<string>("Messages", "Body", "attack {0}", "Enemies and allies. {0} is body name");
pickup_message = configFile.Bind<string>("Messages", "Pickup", "pickup {0}", "Items and other pickups. {0} is pickup name");
teleporter_message = configFile.Bind<string>("Messages", "Teleporter", "hit the {0}", "Teleporter and portals. {0} is the porter name");
potential_message = configFile.Bind<string>("Messages", "Potential", "open this {0}", "Potentials, which are the sphere drops from void areas, with 3 item options inside. {0} is the potential name");
shop_message = configFile.Bind<string>("Messages", "Shop", "{0} [{1}] here", "Tri-shops and printers. {0} is the building name, {1} is the item name");
other_message = configFile.Bind<string>("Messages", "Other", "{0} here", "For anything else. {0} is the display name");
RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, new Action(SetupEliteColors));
if (RiskofOptions.enabled)
{
DoRoO();
}
}
private static void SetupEliteColors()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
//IL_0172: Unknown result type (might be due to invalid IL or missing references)
//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
//IL_0244: Unknown result type (might be due to invalid IL or missing references)
//IL_0280: Unknown result type (might be due to invalid IL or missing references)
//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
elite_colors.Add(Elites.Fire, configFile.Bind<Color>("Elite colors", "Blazing", new Color(0.8f, 0.21f, 0.15f), "Color hex: (Red, Green, Blue, Alpha)"));
elite_colors.Add(Elites.FireHonor, elite_colors[Elites.Fire]);
elite_colors.Add(Elites.Haunted, configFile.Bind<Color>("Elite colors", "Celestine", new Color(0.55f, 0.79f, 0.8f), "Color hex: (Red, Green, Blue, Alpha)"));
elite_colors.Add(Elites.Ice, configFile.Bind<Color>("Elite colors", "Glacial", new Color(0.84f, 0.96f, 0.97f), "Color hex: (Red, Green, Blue, Alpha)"));
elite_colors.Add(Elites.IceHonor, elite_colors[Elites.Ice]);
elite_colors.Add(Elites.Lightning, configFile.Bind<Color>("Elite colors", "Overloading", new Color(0.3f, 0.45f, 1f), "Color hex: (Red, Green, Blue, Alpha)"));
elite_colors.Add(Elites.LightningHonor, elite_colors[Elites.Lightning]);
elite_colors.Add(Elites.Lunar, configFile.Bind<Color>("Elite colors", "Perfected", new Color(0.34f, 0.45f, 0.58f), "Color hex: (Red, Green, Blue, Alpha)"));
elite_colors.Add(Elites.Poison, configFile.Bind<Color>("Elite colors", "Malachite", new Color(0.58f, 0.86f, 0.61f), "Color hex: (Red, Green, Blue, Alpha)"));
elite_colors.Add(Elites.Earth, configFile.Bind<Color>("Elite colors", "Mending", new Color(0.63f, 0.91f, 0.31f), "Color hex: (Red, Green, Blue, Alpha)"));
elite_colors.Add(Elites.EarthHonor, elite_colors[Elites.Earth]);
elite_colors.Add(Elites.Void, configFile.Bind<Color>("Elite colors", "Voidtouched", new Color(0.86f, 0.44f, 0.93f), "Color hex: (Red, Green, Blue, Alpha)"));
elite_colors.Add(Elites.Aurelionite, configFile.Bind<Color>("Elite colors", "Gilded", new Color(1f, 0.8f, 0.06f), "Color hex: (Red, Green, Blue, Alpha)"));
elite_colors.Add(Elites.Bead, configFile.Bind<Color>("Elite colors", "Twisted", new Color(0.52f, 0.8f, 1f), "Color hex: (Red, Green, Blue, Alpha)"));
elite_colors.Add(Elites.Collective, configFile.Bind<Color>("Elite colors", "Twisted", new Color(0.49f, 0.96f, 1f), "Color hex: (Red, Green, Blue, Alpha)"));
if (RiskofOptions.enabled)
{
DoRoOColors();
}
}
private static void DoRoO()
{
RiskofOptions.SetSpriteDefaultIcon();
RiskofOptions.AddOption((ConfigEntryBase)(object)chatToggle);
RiskofOptions.AddOption((ConfigEntryBase)(object)itemIconToggle);
RiskofOptions.AddOption((ConfigEntryBase)(object)shopItemIconToggle);
RiskofOptions.AddOption((ConfigEntryBase)(object)enemyIconToggle);
RiskofOptions.AddOption((ConfigEntryBase)(object)enemyIconColorToggle);
RiskofOptions.AddOption((ConfigEntryBase)(object)moveDuration);
RiskofOptions.AddOption((ConfigEntryBase)(object)interactDuration);
RiskofOptions.AddOption((ConfigEntryBase)(object)itemDuration);
RiskofOptions.AddOption((ConfigEntryBase)(object)enemyDuration);
RiskofOptions.AddOption((ConfigEntryBase)(object)itemIconColor);
RiskofOptions.AddOption((ConfigEntryBase)(object)interactableIconColor);
RiskofOptions.AddOption((ConfigEntryBase)(object)attack_message);
RiskofOptions.AddOption((ConfigEntryBase)(object)pickup_message);
RiskofOptions.AddOption((ConfigEntryBase)(object)teleporter_message);
RiskofOptions.AddOption((ConfigEntryBase)(object)potential_message);
RiskofOptions.AddOption((ConfigEntryBase)(object)shop_message);
RiskofOptions.AddOption((ConfigEntryBase)(object)other_message);
}
private static void DoRoOColors()
{
foreach (ConfigEntry<Color> item in elite_colors.Values.Distinct())
{
RiskofOptions.AddOption((ConfigEntryBase)(object)item);
}
}
}
internal static class Messages
{
private static bool keyDown;
private static bool keySpent;
internal static void CheckInput()
{
//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_000d: 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_0029: 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)
KeyboardShortcut value = Config.chatKey.Value;
if (Input.GetKeyDown(((KeyboardShortcut)(ref value)).MainKey))
{
keyDown = true;
}
value = Config.chatKey.Value;
if (Input.GetKeyUp(((KeyboardShortcut)(ref value)).MainKey))
{
keyDown = false;
keySpent = false;
}
}
internal static void CheckMessageKey_On_CheckPinging(Action<PlayerCharacterMasterController> orig, PlayerCharacterMasterController self)
{
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Invalid comparison between Unknown and I4
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Invalid comparison between Unknown and I4
//IL_0157: Unknown result type (might be due to invalid IL or missing references)
//IL_015c: Unknown result type (might be due to invalid IL or missing references)
orig(self);
if (!keyDown || keySpent)
{
return;
}
PingIndicator pingIndicator = self.pingerController.pingIndicator;
GameObject val = ((pingIndicator != null) ? pingIndicator.pingTarget : null);
if (!Object.op_Implicit((Object)(object)val))
{
return;
}
if ((int)pingIndicator.pingType == 1)
{
string bestBodyName = Util.GetBestBodyName(val);
SendChatMessage(string.Format(CultureInfo.InvariantCulture, Config.attack_message.Value, bestBodyName));
}
else
{
if ((int)pingIndicator.pingType != 2)
{
return;
}
IDisplayNameProvider componentInParent = val.GetComponentInParent<IDisplayNameProvider>();
if (componentInParent == null)
{
log.error("null displayNameProvider");
return;
}
string displayName = componentInParent.GetDisplayName();
if (Object.op_Implicit((Object)(object)val.GetComponent<GenericPickupController>()))
{
SendChatMessage(string.Format(CultureInfo.InvariantCulture, Config.pickup_message.Value, displayName));
}
else if (Object.op_Implicit((Object)(object)val.GetComponent<SceneExitController>()))
{
SendChatMessage(string.Format(CultureInfo.InvariantCulture, Config.teleporter_message.Value, displayName));
}
else if (Object.op_Implicit((Object)(object)val.GetComponent<PickupIndexNetworker>()) && Object.op_Implicit((Object)(object)val.GetComponent<PickupPickerController>()))
{
SendChatMessage(string.Format(CultureInfo.InvariantCulture, Config.potential_message.Value, displayName));
}
else if (Object.op_Implicit((Object)(object)val.GetComponent<ShopTerminalBehavior>()))
{
ShopTerminalBehavior component = val.GetComponent<ShopTerminalBehavior>();
SendChatMessage(string.Format(arg1: (component.pickupIndexIsHidden || !Object.op_Implicit((Object)(object)component.pickupDisplay)) ? "?" : Language.GetString(PickupCatalog.GetPickupDef(component.CurrentPickup().pickupIndex)?.nameToken ?? PickupCatalog.invalidPickupToken), provider: CultureInfo.InvariantCulture, format: Config.shop_message.Value, arg0: displayName));
}
else
{
SendChatMessage(string.Format(CultureInfo.InvariantCulture, Config.other_message.Value, displayName));
}
}
keySpent = true;
}
private static void SendChatMessage(string message)
{
Console.instance.SubmitCmd(NetworkUser.readOnlyLocalPlayersList[0], "say \"" + message + "\"", false);
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("dolso.pingchat", "ColoredPingChat", "1.2.5")]
public class PingChat : BaseUnityPlugin
{
private static EliteDef current_elite;
private static PickupDef currentPickupDef;
private static Shader defaultSpriteShader;
private static Shader itemIconShader;
private void Awake()
{
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Expected O, but got Unknown
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Expected O, but got Unknown
Config.DoConfigs(((BaseUnityPlugin)this).Config);
LoadShader();
HookManager.SetPriority(null, null, null, new string[1] { "*" });
HookManager.Hook(typeof(PingIndicator), "RebuildPing", (Delegate)new Action<Action<PingIndicator>, PingIndicator>(Icons_On_PingIndicator_RebuildPing));
HookManager.Hook(typeof(PingIndicator), "RebuildPing", new Manipulator(Text_IL_PingIndicator_RebuildPing));
HookManager.Hook(typeof(PingIndicator), "GetFormattedTargetString", new Manipulator(ModifyNameColor_IL_PingIndicator_GetFormattedTargetString));
HookManager.Hook(typeof(PlayerCharacterMasterController), "CheckPinging", (Delegate)new Action<Action<PlayerCharacterMasterController>, PlayerCharacterMasterController>(Messages.CheckMessageKey_On_CheckPinging));
}
private void Update()
{
Messages.CheckInput();
}
private void Icons_On_PingIndicator_RebuildPing(Action<PingIndicator> orig, PingIndicator self)
{
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Invalid comparison between Unknown and I4
//IL_0186: Unknown result type (might be due to invalid IL or missing references)
//IL_018c: Invalid comparison between Unknown and I4
//IL_0125: Unknown result type (might be due to invalid IL or missing references)
//IL_0130: Unknown result type (might be due to invalid IL or missing references)
//IL_0204: Unknown result type (might be due to invalid IL or missing references)
//IL_0174: Unknown result type (might be due to invalid IL or missing references)
//IL_0162: Unknown result type (might be due to invalid IL or missing references)
self.defaultPingDuration = Config.moveDuration.Value;
self.interactablePingDuration = Config.interactDuration.Value;
self.enemyPingDuration = Config.enemyDuration.Value;
if ((Object)(object)defaultSpriteShader == (Object)null)
{
defaultSpriteShader = ((Renderer)self.interactablePingGameObjects[0].GetComponent<SpriteRenderer>()).material.shader;
}
else
{
SpriteRenderer component = self.interactablePingGameObjects[0].GetComponent<SpriteRenderer>();
((Renderer)component).material.shader = defaultSpriteShader;
((Component)component).transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);
}
orig(self);
if ((int)self.pingType == 1 && Config.enemyIconToggle.Value)
{
SpriteRenderer component2 = self.enemyPingGameObjects[0].GetComponent<SpriteRenderer>();
if (!Object.op_Implicit((Object)(object)component2))
{
log.warning("no enemy sprite");
return;
}
CharacterBody component3 = self.pingTarget.GetComponent<CharacterBody>();
if (!Object.op_Implicit((Object)(object)component3))
{
log.warning("no enemy body");
return;
}
Texture portraitIcon = component3.portraitIcon;
Texture2D val = (Texture2D)(object)((portraitIcon is Texture2D) ? portraitIcon : null);
Rect val2 = default(Rect);
((Rect)(ref val2))..ctor(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height);
component2.sprite = Sprite.Create(val, val2, new Vector2(0.5f, 0.5f));
if (Config.enemyIconColorToggle.Value && current_elite != null)
{
component2.color = Config.elite_colors[current_elite].Value;
}
else
{
component2.color = Config.not_elite_color.Value;
}
current_elite = null;
}
else if ((int)self.pingType == 2 && currentPickupDef != null && Config.itemIconToggle.Value)
{
SpriteRenderer component4 = self.interactablePingGameObjects[0].GetComponent<SpriteRenderer>();
if (!Object.op_Implicit((Object)(object)component4))
{
Debug.LogWarning((object)"no sprite");
return;
}
component4.sprite = currentPickupDef.iconSprite;
((Component)component4).transform.localScale = new Vector3(Config.itemScale.Value * 0.1f, Config.itemScale.Value * 0.1f, 0.1f);
currentPickupDef = null;
}
}
private void Text_IL_PingIndicator_RebuildPing(ILContext il)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_020e: Unknown result type (might be due to invalid IL or missing references)
//IL_021a: Unknown result type (might be due to invalid IL or missing references)
//IL_022c: Unknown result type (might be due to invalid IL or missing references)
//IL_0251: Unknown result type (might be due to invalid IL or missing references)
//IL_0302: Unknown result type (might be due to invalid IL or missing references)
//IL_0314: Unknown result type (might be due to invalid IL or missing references)
//IL_0320: Unknown result type (might be due to invalid IL or missing references)
//IL_0366: Unknown result type (might be due to invalid IL or missing references)
//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
int textIndex = -1;
if (!val.TryGotoNext(new Func<Instruction, bool>[1]
{
(Instruction a) => ILPatternMatchingExt.MatchCallOrCallvirt(a, typeof(Util), "GetBestBodyName")
}) || !val.TryGotoNext(new Func<Instruction, bool>[1]
{
(Instruction a) => ILPatternMatchingExt.MatchStloc(a, ref textIndex)
}))
{
val.LogErrorCaller("failed to find text");
}
if (textIndex != -1 && val.TryGotoNext(new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchLdstr(x, "PLAYER_PING_ENEMY")
}) && val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, textIndex)
}))
{
val.Emit(OpCodes.Ldarg_0);
val.EmitDelegate<Func<string, PingIndicator, string>>((Func<string, PingIndicator, string>)func);
}
else
{
val.LogErrorCaller("failed to find enemy ping");
}
int interactableIconIndex = -1;
if (!val.TryGotoNext(new Func<Instruction, bool>[1]
{
(Instruction a) => ILPatternMatchingExt.MatchCallOrCallvirt<PingIndicator>(a, "GetInteractableIcon")
}) || !val.TryGotoNext(new Func<Instruction, bool>[1]
{
(Instruction a) => ILPatternMatchingExt.MatchStloc(a, ref interactableIconIndex)
}))
{
val.LogErrorCaller("failed to find interactableIcon");
}
int spriteRendererIndex = -1;
if (!val.TryGotoNext(new Func<Instruction, bool>[1]
{
(Instruction a) => ILPatternMatchingExt.MatchCallOrCallvirt(a, (MethodBase)typeof(GameObject).GetMethod("GetComponent", Type.EmptyTypes).MakeGenericMethod(typeof(SpriteRenderer)))
}) || !val.TryGotoNext(new Func<Instruction, bool>[1]
{
(Instruction a) => ILPatternMatchingExt.MatchStloc(a, ref spriteRendererIndex)
}))
{
val.LogErrorCaller("failed to find spriteRenderer");
}
if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[2]
{
(Instruction a) => ILPatternMatchingExt.MatchCallOrCallvirt<ShopTerminalBehavior>(a, "CurrentPickup"),
(Instruction a) => ILPatternMatchingExt.MatchLdfld<UniquePickup>(a, "pickupIndex")
}))
{
val.LogErrorCaller("failed to find shop/printer pickupIndex for shader replacement");
}
else
{
val.Emit(OpCodes.Dup);
val.Emit(OpCodes.Ldloc, interactableIconIndex);
val.Emit(OpCodes.Ldloc, spriteRendererIndex);
val.EmitDelegate<Func<PickupIndex, Sprite, SpriteRenderer, Sprite>>((Func<PickupIndex, Sprite, SpriteRenderer, Sprite>)func);
val.Emit(OpCodes.Stloc, interactableIconIndex);
}
if (val.TryGotoNext(new Func<Instruction, bool>[1]
{
(Instruction a) => ILPatternMatchingExt.MatchLdstr(a, "Shrine")
}) && val.TryGotoNext(new Func<Instruction, bool>[1]
{
(Instruction a) => ILPatternMatchingExt.MatchStfld(a, typeof(PingIndicator), "pingDuration")
}))
{
val.Emit(OpCodes.Pop);
val.EmitDelegate<Func<float>>((Func<float>)(() => Config.itemDuration.Value));
}
else
{
val.LogErrorCaller("failed to properly set pingDuration");
}
val.Emit(OpCodes.Ldloc, textIndex);
val.Emit(OpCodes.Ldarg_0);
val.Emit(OpCodes.Call, (MethodBase)typeof(PingIndicator).GetMethod("get_pingTarget"));
val.EmitDelegate<Func<string, GameObject, string>>((Func<string, GameObject, string>)delegate(string name, GameObject target)
{
//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_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
GenericPickupController component2 = target.GetComponent<GenericPickupController>();
if (Object.op_Implicit((Object)(object)component2))
{
currentPickupDef = PickupCatalog.GetPickupDef(component2.pickup.pickupIndex);
if (Config.chatToggle.Value)
{
return Util.GenerateColoredString(name, Color32.op_Implicit(currentPickupDef.baseColor));
}
return name;
}
if (!Config.chatToggle.Value)
{
return name;
}
PickupIndexNetworker component3 = target.GetComponent<PickupIndexNetworker>();
if (Object.op_Implicit((Object)(object)component3))
{
return Util.GenerateColoredString(name, Color32.op_Implicit(PickupCatalog.GetPickupDef(component3.pickupState.pickupIndex).baseColor));
}
PickupDropletController component4 = target.GetComponent<PickupDropletController>();
if (Object.op_Implicit((Object)(object)component4))
{
Debug.Log((object)"PICKUPDROPLETCONTROLLER");
return Util.GenerateColoredString(name, Color32.op_Implicit(PickupCatalog.GetPickupDef(component4.pickupState.pickupIndex).baseColor));
}
return name;
});
val.Emit(OpCodes.Stloc, textIndex);
if (!val.TryGotoNext(new Func<Instruction, bool>[1]
{
(Instruction a) => ILPatternMatchingExt.MatchLdfld(a, typeof(PingIndicator), "interactablePingGameObjects")
}))
{
val.LogError("failed to properly go to icon coloring");
}
val.Emit(OpCodes.Ldloc, spriteRendererIndex);
val.EmitDelegate<Func<Color>>((Func<Color>)get_icon_color);
val.Emit(OpCodes.Callvirt, (MethodBase)typeof(SpriteRenderer).GetMethod("set_color"));
static string func(string text, PingIndicator self)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: 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_0096: Unknown result type (might be due to invalid IL or missing references)
CharacterBody component = self.pingTarget.GetComponent<CharacterBody>();
if (Object.op_Implicit((Object)(object)component) && component.isElite)
{
BuffIndex[] eliteBuffIndices = BuffCatalog.eliteBuffIndices;
foreach (BuffIndex val2 in eliteBuffIndices)
{
if (component.HasBuff(val2))
{
EliteDef eliteDef = BuffCatalog.GetBuffDef(val2).eliteDef;
if (Config.elite_colors.TryGetValue(eliteDef, out var value))
{
current_elite = eliteDef;
if (Config.chatToggle.Value)
{
string text2 = Language.GetStringFormatted(eliteDef.modifierToken, new object[1] { "" }).Trim();
return text.Replace(text2, Util.GenerateColoredString(text2, Color32.op_Implicit(value.Value)));
}
}
}
}
}
return text;
}
static Sprite func(PickupIndex pickupIndex, Sprite sprite, SpriteRenderer spriteRenderer)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
PickupDef pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
if (Config.shopItemIconToggle.Value && pickupDef != null && (Object)(object)pickupDef.iconSprite != (Object)null)
{
sprite = pickupDef.iconSprite;
((Renderer)spriteRenderer).material.shader = itemIconShader;
((Component)spriteRenderer).transform.localScale = new Vector3(Config.itemScale.Value * 0.1f, Config.itemScale.Value * 0.1f, 0.1f);
}
return sprite;
}
static Color get_icon_color()
{
//IL_0023: 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)
if (Config.itemIconToggle.Value && currentPickupDef != null)
{
return Config.itemIconColor.Value;
}
return Config.interactableIconColor.Value;
}
}
private static void ModifyNameColor_IL_PingIndicator_GetFormattedTargetString(ILContext il)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
{
(Instruction a) => ILPatternMatchingExt.MatchCallOrCallvirt<Language>(a, "GetString")
}))
{
val.Emit(OpCodes.Ldarg_1);
val.EmitDelegate<Func<string, PickupIndex, string>>((Func<string, PickupIndex, string>)color_pickup_string);
}
else
{
val.LogErrorCaller("shop name");
}
if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchLdstr(x, "?")
}))
{
val.Emit(OpCodes.Ldarg_1);
val.EmitDelegate<Func<string, PickupIndex, string>>((Func<string, PickupIndex, string>)color_pickup_string);
}
else
{
val.LogErrorCaller("Failed to find ? item");
}
static string color_pickup_string(string name, PickupIndex pickupindex)
{
//IL_000d: 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_0018: Unknown result type (might be due to invalid IL or missing references)
if (Config.chatToggle.Value)
{
return Util.GenerateColoredString(name, Color32.op_Implicit(PickupCatalog.GetPickupDef(pickupindex).baseColor));
}
return name;
}
}
private static void LoadShader()
{
try
{
AssetBundle obj = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "itemicon"));
itemIconShader = obj.LoadAsset<Shader>("ItemIcon.shader");
obj.Unload(false);
}
catch (Exception ex)
{
log.error("Failed to load assetbundle\n" + ex);
}
}
[ConCommand(/*Could not decode attribute arguments.*/)]
private static void CCReloadConfig(ConCommandArgs args)
{
Config.configFile.Reload();
}
}
}
