using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
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(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("Coruscnium")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Warframe-style enemy highlight, outline, and target tint with configurable colors and intensity")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0.0")]
[assembly: AssemblyProduct("EnemyHighlights")]
[assembly: AssemblyTitle("EnemyHighlights")]
[assembly: AssemblyVersion("1.1.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[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 EnemyHighlights
{
[BepInPlugin("coruscnium.enemyhighlights", "EnemyHighlights", "1.1.0.0")]
[BepInProcess("Mycopunk.exe")]
[MycoMod(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
private static class RimPainter
{
private static readonly int BaseColorId = Shader.PropertyToID("_BaseColor");
private static readonly int PowerId = Shader.PropertyToID("_Power");
private static readonly int IntensityId = Shader.PropertyToID("_Intensity");
private static readonly int AlphaId = Shader.PropertyToID("_Alpha");
private static readonly HashSet<EnemyPart> Parts = new HashSet<EnemyPart>();
private static readonly List<EnemyPart> Iter = new List<EnemyPart>();
private static Material RimMat;
private static RenderParams RimParams;
internal static void SetSourceMaterial(Material mat)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
RimMat = mat;
RenderParams rimParams = default(RenderParams);
((RenderParams)(ref rimParams))..ctor(mat);
((RenderParams)(ref rimParams)).layer = 0;
((RenderParams)(ref rimParams)).renderingLayerMask = 1u;
RimParams = rimParams;
}
internal static void Register(EnemyPart part)
{
if ((Object)(object)part != (Object)null)
{
Parts.Add(part);
}
}
internal static void Render()
{
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
//IL_0140: Unknown result type (might be due to invalid IL or missing references)
//IL_015a: Unknown result type (might be due to invalid IL or missing references)
if (!_rimReady || _highlightStrength <= 0f || (Object)(object)RimMat == (Object)null || Parts.Count == 0)
{
return;
}
ApplyProperties();
Iter.Clear();
Iter.AddRange(Parts);
for (int i = 0; i < Iter.Count; i++)
{
EnemyPart val = Iter[i];
if (val == null || !Object.op_Implicit((Object)(object)val))
{
Parts.Remove(val);
}
else
{
if (!((Behaviour)val).isActiveAndEnabled)
{
continue;
}
EnemyBrain brain = val.Brain;
if (brain != null && brain.DigProgress > 0f)
{
continue;
}
List<TargetMesh> meshes = val.Meshes;
if (meshes == null)
{
continue;
}
for (int j = 0; j < meshes.Count; j++)
{
TargetMesh val2 = meshes[j];
if (val2 == null || val2.mesh == null)
{
continue;
}
Mesh sharedMesh = val2.mesh.sharedMesh;
if (sharedMesh != null)
{
Matrix4x4 localToWorldMatrix = ((Component)val2.mesh).transform.localToWorldMatrix;
int subMeshCount = sharedMesh.subMeshCount;
for (int k = 0; k < subMeshCount; k++)
{
Graphics.RenderMesh(ref RimParams, sharedMesh, k, localToWorldMatrix, (Matrix4x4?)null);
}
}
}
}
}
}
private static void ApplyProperties()
{
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
float num = Mathf.Lerp(0.5f, 20f, _highlightStrength);
float num2 = Mathf.Lerp(0.8f, 3f, _highlightStrength);
RimMat.SetColor(BaseColorId, _highlightColor);
RimMat.SetFloat(PowerId, num2);
RimMat.SetFloat(IntensityId, num);
RimMat.SetFloat(AlphaId, 1f);
}
internal static void Reapply()
{
if (_rimReady)
{
}
}
}
private static class EnemyPartPatches
{
[HarmonyPatch(typeof(EnemyPart), "Initialize")]
[HarmonyPostfix]
private static void Initialize_Postfix(EnemyPart __instance)
{
RimPainter.Register(__instance);
}
[HarmonyPatch(typeof(EnemyPart), "SetupRenderersOnAttach")]
[HarmonyPostfix]
private static void SetupRenderersOnAttach_Postfix(EnemyPart __instance)
{
RimPainter.Register(__instance);
}
}
private static class HighlighterPatches
{
private static readonly FieldInfo GradientField = AccessTools.Field(typeof(Highlighter), "highlightHealthColor");
private static readonly FieldInfo OpacityField = AccessTools.Field(typeof(Highlighter), "highlightOpacity");
private static Gradient _vanillaGradient;
private static Range<float> _vanillaOpacity;
private static bool _captured;
[HarmonyPatch(typeof(Highlighter), "Setup")]
[HarmonyPostfix]
private static void Setup_Postfix(Highlighter __instance)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: 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)
Gradient val = (Gradient)GradientField.GetValue(__instance);
Range<float> vanillaOpacity = (Range<float>)OpacityField.GetValue(__instance);
if (!_captured || !(_targetingStrength > 0f) || !IsOurOverride(val))
{
_vanillaGradient = val;
_vanillaOpacity = vanillaOpacity;
_captured = true;
}
ApplyTargetingOverride();
}
private static bool IsOurOverride(Gradient gradient)
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: 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)
if (gradient == null || gradient.colorKeys == null)
{
return false;
}
GradientColorKey[] colorKeys = gradient.colorKeys;
if (colorKeys.Length != 2)
{
return false;
}
return colorKeys[0].color == _targetingColor && colorKeys[1].color == _targetingColor;
}
internal static void ApplyTargetingOverride()
{
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Expected O, but got Unknown
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: 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_0049: Unknown result type (might be due to invalid IL or missing references)
Highlighter obj = default(Highlighter);
if (_captured && Highlighter.TryGetInstance(ref obj))
{
if (_targetingStrength <= 0f)
{
GradientField.SetValue(obj, _vanillaGradient);
OpacityField.SetValue(obj, _vanillaOpacity);
return;
}
Gradient val = new Gradient();
val.colorKeys = (GradientColorKey[])(object)new GradientColorKey[2]
{
new GradientColorKey(_targetingColor, 0f),
new GradientColorKey(_targetingColor, 1f)
};
val.alphaKeys = (GradientAlphaKey[])(object)new GradientAlphaKey[2]
{
new GradientAlphaKey(1f, 0f),
new GradientAlphaKey(1f, 1f)
};
Gradient value = val;
GradientField.SetValue(obj, value);
OpacityField.SetValue(obj, new Range<float>(_targetingStrength, _targetingStrength));
}
}
}
public const string PluginGUID = "coruscnium.enemyhighlights";
public const string PluginName = "EnemyHighlights";
public const string PluginVersion = "1.1.0.0";
internal static ManualLogSource Logger;
private static ConfigEntry<string> _highlightColorCfg;
private static ConfigEntry<int> _highlightIntensityCfg;
private static ConfigEntry<string> _targetingColorCfg;
private static ConfigEntry<int> _targetingIntensityCfg;
private static Color _highlightColor = Color.red;
private static float _highlightStrength;
private static Color _targetingColor = Color.red;
private static float _targetingStrength;
private const string BundleFileName = "enemyhighlights_rim";
private static AssetBundle _bundle;
private static bool _rimReady;
private static FileSystemWatcher _configWatcher;
private static volatile bool _pendingConfigReload;
private static DateTime _lastWatcherEvent = DateTime.MinValue;
private const double DebounceSeconds = 0.05;
private void Awake()
{
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Expected O, but got Unknown
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Expected O, but got Unknown
//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
//IL_01bf: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
_highlightColorCfg = ((BaseUnityPlugin)this).Config.Bind<string>("Highlight", "HighlightColor", "FF2A00", "Hex color (RRGGBB) for the enemy fresnel rim glow.");
_highlightIntensityCfg = ((BaseUnityPlugin)this).Config.Bind<int>("Highlight", "HighlightIntensity", 30, new ConfigDescription("0 disables (vanilla). 100 = brightest, tightest rim glow.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
_targetingColorCfg = ((BaseUnityPlugin)this).Config.Bind<string>("Targeting", "TargetingColor", "FF2A00", "Hex color (RRGGBB) for the pointed-at part overlay.");
_targetingIntensityCfg = ((BaseUnityPlugin)this).Config.Bind<int>("Targeting", "TargetingIntensity", 0, new ConfigDescription("0 disables (vanilla health-gradient overlay). 100 = fully opaque overlay.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
((BaseUnityPlugin)this).Config.SettingChanged += OnSettingChanged;
((BaseUnityPlugin)this).Config.Save();
try
{
_configWatcher = new FileSystemWatcher(Paths.ConfigPath, "coruscnium.enemyhighlights.cfg")
{
NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite),
EnableRaisingEvents = true
};
_configWatcher.Changed += OnConfigFileChanged;
_configWatcher.Created += OnConfigFileChanged;
_configWatcher.Renamed += OnConfigFileChanged;
}
catch (Exception ex)
{
Logger.LogWarning((object)("Could not start config file watcher: " + ex.Message));
}
RefreshCachedValues();
LoadRimBundle();
Harmony val = new Harmony("coruscnium.enemyhighlights");
val.PatchAll(typeof(EnemyPartPatches));
val.PatchAll(typeof(HighlighterPatches));
Logger.LogInfo((object)"EnemyHighlights 1.1.0.0 loaded.");
}
private void LoadRimBundle()
{
//IL_010b: Unknown result type (might be due to invalid IL or missing references)
//IL_0112: Expected O, but got Unknown
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
if (string.IsNullOrEmpty(directoryName))
{
Logger.LogError((object)"[rim] Could not resolve plugin DLL directory. Rim highlight disabled.");
return;
}
string text = Path.Combine(directoryName, "enemyhighlights_rim");
if (!File.Exists(text))
{
Logger.LogError((object)("[rim] AssetBundle not found at '" + text + "'. The rim shader cannot load. Reinstall the mod (ensure enemyhighlights_rim is in BepInEx/plugins/EnemyHighlights/)."));
return;
}
try
{
_bundle = AssetBundle.LoadFromFile(text);
if ((Object)(object)_bundle == (Object)null)
{
Logger.LogError((object)("[rim] Failed to load AssetBundle from '" + text + "'. Rim highlight disabled."));
return;
}
Shader val = _bundle.LoadAsset<Shader>("Assets/RimHighlight.shader");
if ((Object)(object)val == (Object)null)
{
Logger.LogError((object)"[rim] Shader not found in bundle. The bundle may be corrupt or missing the shader asset. Rebuild with Unity 6000.4.0f1.");
return;
}
if (((Object)val).name == "Hidden/InternalErrorShader")
{
Logger.LogError((object)"[rim] Shader compiled to pink-fallback. The bundle was likely built with a Unity version that doesn't match the game (6000.4.0f1) or with missing shader includes. Rebuild the shader bundle.");
return;
}
Material val2 = new Material(val);
((Object)val2).name = "RimHighlight [EnemyHighlights]";
((Object)val2).hideFlags = (HideFlags)61;
RimPainter.SetSourceMaterial(val2);
_rimReady = true;
Logger.LogInfo((object)("[rim] Bundle loaded — shader '" + ((Object)val).name + "', material created."));
}
catch (Exception arg)
{
Logger.LogError((object)$"[rim] Exception loading AssetBundle: {arg}");
}
}
private static void OnSettingChanged(object sender, SettingChangedEventArgs args)
{
RefreshCachedValues();
RimPainter.Reapply();
HighlighterPatches.ApplyTargetingOverride();
}
private static void OnConfigFileChanged(object sender, FileSystemEventArgs e)
{
DateTime utcNow = DateTime.UtcNow;
if (!((utcNow - _lastWatcherEvent).TotalSeconds < 0.05))
{
_lastWatcherEvent = utcNow;
_pendingConfigReload = true;
}
}
private void Update()
{
if (_pendingConfigReload)
{
_pendingConfigReload = false;
try
{
((BaseUnityPlugin)this).Config.Reload();
}
catch (IOException)
{
_pendingConfigReload = true;
}
catch (Exception ex2)
{
Logger.LogWarning((object)("Config reload failed: " + ex2.Message));
}
}
}
private void LateUpdate()
{
RimPainter.Render();
}
private void OnDestroy()
{
if (_configWatcher != null)
{
_configWatcher.EnableRaisingEvents = false;
_configWatcher.Changed -= OnConfigFileChanged;
_configWatcher.Created -= OnConfigFileChanged;
_configWatcher.Renamed -= OnConfigFileChanged;
_configWatcher.Dispose();
_configWatcher = null;
}
if ((Object)(object)_bundle != (Object)null)
{
_bundle.Unload(true);
_bundle = null;
}
_rimReady = false;
}
private static void RefreshCachedValues()
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//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_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
_highlightColor = ParseHex(_highlightColorCfg.Value, Color.red);
_highlightStrength = (float)Mathf.Clamp(_highlightIntensityCfg.Value, 0, 100) / 100f;
_targetingColor = ParseHex(_targetingColorCfg.Value, Color.red);
_targetingStrength = (float)Mathf.Clamp(_targetingIntensityCfg.Value, 0, 100) / 100f;
}
private static Color ParseHex(string hex, Color fallback)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
if (string.IsNullOrWhiteSpace(hex))
{
return fallback;
}
string text = hex.Trim();
if (!text.StartsWith("#"))
{
text = "#" + text;
}
Color val = default(Color);
return ColorUtility.TryParseHtmlString(text, ref val) ? val : fallback;
}
}
}
