using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using PluginConfig.API;
using PluginConfig.API.Decorators;
using PluginConfig.API.Fields;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("RADIKILL")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("nkRADIKILL")]
[assembly: AssemblyTitle("RADIKILL")]
[assembly: AssemblyVersion("1.0.0.0")]
[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;
}
}
}
public class RadianceConfig
{
public bool isEnforced = false;
public bool isEnabled = false;
public float tier = 1f;
public float health = 1.5f;
public float damage = 1.5f;
public float speed = 1.5f;
public RadianceConfig()
{
}
public RadianceConfig(bool radIsEnforced, bool radIsEnabled, float radTier, float radHealth, float radDamage, float radSpeed)
{
isEnforced = radIsEnforced;
isEnabled = radIsEnabled;
tier = radTier;
health = radHealth;
damage = radDamage;
speed = radSpeed;
}
}
namespace RADIKILL
{
[BepInPlugin("net.nkmi.radikill", "nkRADIKILL", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
internal static Harmony harmony;
public static PluginConfig pluginConfig;
internal static ManualLogSource Logger { get; private set; }
private void Awake()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
harmony = new Harmony("net.nkmi.radikill");
harmony.PatchAll();
pluginConfig = new PluginConfig();
pluginConfig.onConfigChanged += delegate
{
updateEnemies();
};
((Object)((Component)this).gameObject).hideFlags = (HideFlags)4;
Logger.LogInfo((object)"nkRADIKILL loaded :3c");
}
public void OnDestroy()
{
harmony.UnpatchSelf();
}
public static void applyRadianceConfig(EnemyIdentifier enemy)
{
//IL_0007: 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)
if (pluginConfig.isEnemyAffected(enemy.enemyType))
{
MonoSingleton<AssistController>.Instance.cheatsEnabled = true;
RadianceConfig configForEnemy = pluginConfig.getConfigForEnemy(enemy.enemyType);
enemy.radianceTier = configForEnemy.tier;
enemy.healthBuffModifier = configForEnemy.health;
enemy.damageBuffModifier = configForEnemy.damage;
enemy.speedBuffModifier = configForEnemy.speed;
enemy.UnbuffAll();
if (configForEnemy.isEnabled)
{
enemy.BuffAll();
}
}
}
public static void updateEnemies()
{
EnemyIdentifier[] array = Object.FindObjectsOfType<EnemyIdentifier>();
foreach (EnemyIdentifier enemy in array)
{
applyRadianceConfig(enemy);
}
}
}
[HarmonyPatch]
public static class PluginPatches
{
[HarmonyPrefix]
[HarmonyPatch(typeof(EnemyIdentifier), "Start")]
private static bool onStart(EnemyIdentifier __instance)
{
Plugin.applyRadianceConfig(__instance);
return true;
}
}
public class PluginConfig
{
private PluginConfigurator configurator = null;
private Dictionary<EnemyType, RadianceConfig> enemyConfigs = new Dictionary<EnemyType, RadianceConfig>();
private RadianceConfig globalRadianceConfig = new RadianceConfig();
public bool enablePlugin = false;
public event EventHandler onConfigChanged = null;
private void invokeChangedEvent()
{
this.onConfigChanged?.Invoke(this, EventArgs.Empty);
}
public bool isEnemyAffected(EnemyType enemyType)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
if (!enablePlugin || !enemyConfigs.ContainsKey(enemyType))
{
return false;
}
if (globalRadianceConfig.isEnforced)
{
return true;
}
RadianceConfig radianceConfig = enemyConfigs[enemyType];
return radianceConfig.isEnforced;
}
public RadianceConfig getConfigForEnemy(EnemyType enemyType)
{
//IL_0014: 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)
if (globalRadianceConfig.isEnforced && !enemyConfigs[enemyType].isEnforced)
{
return globalRadianceConfig;
}
return enemyConfigs[enemyType];
}
private string getEnemyClassPanelName(EnemyClass enemyClass)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected I4, but got Unknown
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
if (1 == 0)
{
}
string result = (int)enemyClass switch
{
0 => "Husks",
2 => "Demons",
1 => "Machines",
3 => "Angels",
_ => Enum.GetName(typeof(EnemyClass), enemyClass) + "s",
};
if (1 == 0)
{
}
return result;
}
private string getEnemyName(EnemyType enemyType)
{
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
Dictionary<EnemyType, string> dictionary = new Dictionary<EnemyType, string>();
dictionary[(EnemyType)2] = "Hideous Mass";
dictionary[(EnemyType)41] = "Mirror Reaper";
dictionary[(EnemyType)4] = "Malicious Face";
dictionary[(EnemyType)20] = "Sentry";
dictionary[(EnemyType)19] = "Sisyphean Insurrectionist";
if (dictionary.ContainsKey(enemyType))
{
return dictionary[enemyType];
}
return Enum.GetName(typeof(EnemyType), enemyType);
}
private List<string> getGlobalConfigExceptions()
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
List<string> list = new List<string>();
foreach (KeyValuePair<EnemyType, RadianceConfig> enemyConfig in enemyConfigs)
{
if (enemyConfig.Value.isEnforced)
{
list.Insert(list.Count, getEnemyName(enemyConfig.Key));
}
}
return list;
}
private string formatExceptionsString(List<string> exceptions)
{
if (exceptions.Count == 1)
{
return "There is 1 enemy overriding these settings: " + exceptions[0];
}
string text = $"There are {exceptions.Count} enemies overriding these settings: ";
for (int i = 0; i < exceptions.Count; i++)
{
text += exceptions[i];
if (i != exceptions.Count - 1)
{
text += ", ";
}
}
return text;
}
private void buildRadiancePanel(ConfigPanel parent, RadianceConfig radianceConfig, string id, string name)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Expected O, but got Unknown
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Expected O, but got Unknown
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Expected O, but got Unknown
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Expected O, but got Unknown
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Expected O, but got Unknown
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Expected O, but got Unknown
//IL_0147: Unknown result type (might be due to invalid IL or missing references)
//IL_0151: Expected O, but got Unknown
//IL_0182: Unknown result type (might be due to invalid IL or missing references)
//IL_018c: Expected O, but got Unknown
//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
//IL_01c7: Expected O, but got Unknown
//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
//IL_01da: Expected O, but got Unknown
//IL_0218: Unknown result type (might be due to invalid IL or missing references)
//IL_0222: Expected O, but got Unknown
//IL_0230: Unknown result type (might be due to invalid IL or missing references)
//IL_023a: Expected O, but got Unknown
//IL_0248: Unknown result type (might be due to invalid IL or missing references)
//IL_0252: Expected O, but got Unknown
//IL_0260: Unknown result type (might be due to invalid IL or missing references)
//IL_026a: Expected O, but got Unknown
//IL_0278: Unknown result type (might be due to invalid IL or missing references)
//IL_0282: Expected O, but got Unknown
//IL_0290: Unknown result type (might be due to invalid IL or missing references)
//IL_029a: Expected O, but got Unknown
string id2 = id;
RadianceConfig radianceConfig2 = radianceConfig;
ConfigPanel val = new ConfigPanel(parent, name, id2 + "_panel");
ConfigHeader header = new ConfigHeader(val, "", 24);
((ConfigField)header).hidden = true;
BoolField enforceToggle = new BoolField(val, "Enforce radiance", id2 + "_isEnforced", false);
ConfigDivision div = new ConfigDivision(val, id2 + "_radiance_division");
BoolField radianceToggle = new BoolField((ConfigPanel)(object)div, "Enable radiance", id2 + "_isRadiant", true);
ConfigDivision slidersDiv = new ConfigDivision((ConfigPanel)(object)div, id2 + "_radiance_sliders");
FloatSliderField radianceTier = new FloatSliderField((ConfigPanel)(object)slidersDiv, "Tier", id2 + "_tier", new Tuple<float, float>(0.5f, 10f), 1f, 2);
FloatSliderField healthScale = new FloatSliderField((ConfigPanel)(object)slidersDiv, "Health", id2 + "_health", new Tuple<float, float>(0f, 10f), 1.5f, 2);
FloatSliderField damageScale = new FloatSliderField((ConfigPanel)(object)slidersDiv, "Damage", id2 + "_damage", new Tuple<float, float>(0f, 10f), 1.5f, 2);
FloatSliderField speedScale = new FloatSliderField((ConfigPanel)(object)slidersDiv, "Speed", id2 + "_speed", new Tuple<float, float>(0f, 10f), 1.5f, 2);
ConfigHeader footer = new ConfigHeader(val, "", 24);
((ConfigField)footer).hidden = true;
Action updateHeaders = delegate
{
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
if (!enforceToggle.value || id2 != "global")
{
((ConfigField)header).hidden = true;
((ConfigField)footer).hidden = true;
}
else
{
List<string> globalConfigExceptions = getGlobalConfigExceptions();
if (globalConfigExceptions.Count == 0)
{
((ConfigField)footer).hidden = true;
}
else
{
string text = formatExceptionsString(globalConfigExceptions);
((ConfigField)footer).hidden = false;
footer.text = text;
footer.textColor = Color.red;
}
}
};
Action updateRadianceConfig = delegate
{
radianceConfig2.isEnforced = enforceToggle.value;
radianceConfig2.isEnabled = radianceToggle.value;
radianceConfig2.tier = radianceTier.value;
radianceConfig2.health = healthScale.value;
radianceConfig2.damage = damageScale.value;
radianceConfig2.speed = speedScale.value;
((ConfigField)div).interactable = enforceToggle.value;
((ConfigField)slidersDiv).interactable = radianceToggle.value;
invokeChangedEvent();
};
enforceToggle.postValueChangeEvent += (PostBoolValueChangeEvent)delegate
{
updateRadianceConfig();
};
radianceToggle.postValueChangeEvent += (PostBoolValueChangeEvent)delegate
{
updateRadianceConfig();
};
radianceTier.postValueChangeEvent += (PostFloatSliderValueChangeEvent)delegate
{
updateRadianceConfig();
};
healthScale.postValueChangeEvent += (PostFloatSliderValueChangeEvent)delegate
{
updateRadianceConfig();
};
damageScale.postValueChangeEvent += (PostFloatSliderValueChangeEvent)delegate
{
updateRadianceConfig();
};
speedScale.postValueChangeEvent += (PostFloatSliderValueChangeEvent)delegate
{
updateRadianceConfig();
};
onConfigChanged += delegate
{
updateHeaders();
};
updateRadianceConfig();
}
private void buildEnemiesPanel(ConfigPanel parent, EnemyClass enemyClass, EnemyType[] enemyTypes)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: 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)
string enemyClassPanelName = getEnemyClassPanelName(enemyClass);
string text = "Enemies_" + Enum.GetName(typeof(EnemyType), enemyClass);
ConfigPanel parent2 = new ConfigPanel(parent, enemyClassPanelName, text);
foreach (EnemyType val in enemyTypes)
{
RadianceConfig radianceConfig = new RadianceConfig();
enemyConfigs[val] = radianceConfig;
string name = Enum.GetName(typeof(EnemyType), val);
string enemyName = getEnemyName(val);
buildRadiancePanel(parent2, radianceConfig, name, enemyName);
}
}
private void buildEnemyPanels(ConfigPanel parent)
{
EnemyType[] array = new EnemyType[8];
RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
EnemyType[] enemyTypes = (EnemyType[])(object)array;
EnemyType[] array2 = new EnemyType[7];
RuntimeHelpers.InitializeArray(array2, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
EnemyType[] enemyTypes2 = (EnemyType[])(object)array2;
EnemyType[] array3 = new EnemyType[6];
RuntimeHelpers.InitializeArray(array3, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
EnemyType[] enemyTypes3 = (EnemyType[])(object)array3;
EnemyType[] array4 = new EnemyType[3];
RuntimeHelpers.InitializeArray(array4, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
EnemyType[] enemyTypes4 = (EnemyType[])(object)array4;
buildEnemiesPanel(parent, (EnemyClass)0, enemyTypes);
buildEnemiesPanel(parent, (EnemyClass)2, enemyTypes3);
buildEnemiesPanel(parent, (EnemyClass)1, enemyTypes2);
buildEnemiesPanel(parent, (EnemyClass)3, enemyTypes4);
}
private void buildMenu()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Expected O, but got Unknown
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Expected O, but got Unknown
BoolField val = new BoolField(configurator.rootPanel, "Enable RADIKILL", "isActive", false, true, true);
ConfigDivision rootDiv = new ConfigDivision(configurator.rootPanel, "root_div");
((ConfigField)rootDiv).interactable = val.value;
enablePlugin = val.value;
val.onValueChange += (BoolValueChangeEventDelegate)delegate(BoolValueChangeEvent e)
{
((ConfigField)rootDiv).interactable = e.value;
enablePlugin = e.value;
invokeChangedEvent();
};
buildRadiancePanel((ConfigPanel)(object)rootDiv, globalRadianceConfig, "global", "Global");
buildEnemyPanels((ConfigPanel)(object)rootDiv);
}
public PluginConfig()
{
configurator = PluginConfigurator.Create("nkRADIKILL", "net.nkmi.radikill");
buildMenu();
}
}
internal static class MyPluginInfo
{
public const string PLUGIN_GUID = "net.nkmi.radikill";
public const string PLUGIN_NAME = "nkRADIKILL";
public const string PLUGIN_VERSION = "1.0.0";
}
}
