using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using CurseCatcher.Properties;
using HG;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using RoR2;
using UnityEngine;
using UnityEngine.Networking;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.2.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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace CurseCatcher.Properties
{
[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
[DebuggerNonUserCode]
[CompilerGenerated]
internal class Resources
{
private static ResourceManager resourceMan;
private static CultureInfo resourceCulture;
[EditorBrowsable(EditorBrowsableState.Advanced)]
internal static ResourceManager ResourceManager
{
get
{
if (resourceMan == null)
{
resourceMan = new ResourceManager("CurseCatcher.Properties.Resources", typeof(Resources).Assembly);
}
return resourceMan;
}
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
internal static CultureInfo Culture
{
get
{
return resourceCulture;
}
set
{
resourceCulture = value;
}
}
internal static byte[] disabled => (byte[])ResourceManager.GetObject("disabled", resourceCulture);
internal static byte[] enabled => (byte[])ResourceManager.GetObject("enabled", resourceCulture);
internal Resources()
{
}
}
}
namespace Local.Eclipse.CurseCatcher
{
internal static class Artifact
{
private static ArtifactDef definition = null;
private static int ruleIndex = -1;
[HarmonyPatch(typeof(ArtifactCatalog), "SetArtifactDefs")]
[HarmonyPostfix]
private static void CreateArtifact()
{
//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_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: 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_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Expected O, but got Unknown
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Expected O, but got Unknown
definition = new ArtifactDef
{
nameToken = "Artifact of Infliction",
descriptionToken = "Only enemies inflict permanent damage.",
smallIconSelectedSprite = Load(Resources.enabled),
smallIconDeselectedSprite = Load(Resources.disabled),
artifactIndex = (ArtifactIndex)ArtifactCatalog.artifactDefs.Length,
cachedName = "Curse"
};
ArrayUtils.ArrayAppend<ArtifactDef>(ref ArtifactCatalog.artifactDefs, ref definition);
Harmony instance = null;
RunArtifactManager.onArtifactEnabledGlobal += (ArtifactStateChangeDelegate)delegate(RunArtifactManager _, ArtifactDef artifact)
{
if (instance == null && NetworkServer.active && (Object)(object)artifact == (Object)(object)definition)
{
instance = Harmony.CreateAndPatchAll(Plugin.instance.GetType(), (string)null);
}
};
RunArtifactManager.onArtifactDisabledGlobal += (ArtifactStateChangeDelegate)delegate(RunArtifactManager _, ArtifactDef artifact)
{
if ((Object)(object)artifact == (Object)(object)definition)
{
Harmony obj = instance;
if (obj != null)
{
obj.UnpatchSelf();
}
instance = null;
}
};
}
private static Sprite Load(byte[] imageData)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Expected O, but got Unknown
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
Texture2D val = new Texture2D(512, 512, (TextureFormat)5, 4, false);
ImageConversion.LoadImage(val, imageData);
return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2((float)(((Texture)val).width / 2), (float)(((Texture)val).height / 2)));
}
[HarmonyPatch(typeof(RuleCatalog), "Init")]
[HarmonyFinalizer]
private static void AddArtifact(Exception __exception)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
if (__exception != null)
{
throw __exception;
}
RuleDef val = RuleDef.FromArtifact(definition.artifactIndex);
ruleIndex = RuleCatalog.allRuleDefs.Count;
val.globalIndex = ruleIndex;
RuleCatalog.allRuleDefs.Add(val);
RuleCatalog.ruleDefsByGlobalName[val.globalName] = val;
val.category = RuleCatalog.artifactRuleCategory;
RuleCatalog.artifactRuleCategory.children.Add(val);
for (int i = 0; i < val.choices.Count; i++)
{
RuleChoiceDef val2 = val.choices[i];
val2.localIndex = i;
val2.globalIndex = RuleCatalog.allChoicesDefs.Count;
RuleCatalog.allChoicesDefs.Add(val2);
RuleCatalog.ruleChoiceDefsByGlobalName[val2.globalName] = val2;
}
}
[HarmonyPatch(typeof(RuleCatalog), "AddRule")]
[HarmonyPrefix]
private static bool SkipRule(RuleDef ruleDef)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
foreach (RuleChoiceDef choice in ruleDef.choices)
{
if (choice.artifactIndex == definition.artifactIndex)
{
return false;
}
}
return true;
}
[HarmonyPatch(typeof(EclipseRun), "OverrideRuleChoices")]
[HarmonyPostfix]
private static void ShowInEclipse(RuleChoiceMask mustInclude, RuleChoiceMask mustExclude)
{
foreach (RuleChoiceDef item in (IEnumerable<RuleChoiceDef>)((ruleIndex >= 0) ? RuleCatalog.GetRuleDef(ruleIndex).choices : new List<RuleChoiceDef>()))
{
((SerializableBitArray)mustInclude)[item.globalIndex] = false;
((SerializableBitArray)mustExclude)[item.globalIndex] = false;
}
}
[HarmonyPatch(typeof(NetworkExtensions), "Write", new Type[]
{
typeof(NetworkWriter),
typeof(RuleBook)
})]
[HarmonyPrefix]
private static bool WriteRuleBook(NetworkWriter writer, RuleBook src)
{
for (int i = 0; i < src.ruleValues.Length; i++)
{
if (i != ruleIndex)
{
writer.Write(src.ruleValues[i]);
}
}
return false;
}
[HarmonyPatch(typeof(NetworkExtensions), "ReadRuleBook")]
[HarmonyPrefix]
private static bool ReadRuleBook(NetworkReader reader, RuleBook dest)
{
for (int i = 0; i < dest.ruleValues.Length; i++)
{
if (i == ruleIndex)
{
dest.ruleValues[i] = (byte)RuleCatalog.GetRuleDef(ruleIndex).defaultChoiceIndex;
}
else
{
dest.ruleValues[i] = reader.ReadByte();
}
}
return false;
}
[HarmonyPatch(typeof(RunArtifactManager), "OnDeserialize")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> LimitReadLength(IEnumerable<CodeInstruction> IL)
{
MethodInfo readBitArray = typeof(NetworkExtensions).GetMethod("ReadBitArray", new Type[2]
{
typeof(NetworkReader),
typeof(bool[])
});
foreach (CodeInstruction item in IL)
{
if (CodeInstructionExtensions.Calls(item, readBitArray))
{
yield return Transpilers.EmitDelegate<Action<NetworkReader, bool[]>>((Action<NetworkReader, bool[]>)delegate(NetworkReader input, bool[] array)
{
if (definition == null)
{
NetworkExtensions.ReadBitArray(input, array);
}
else
{
NetworkExtensions.ReadBitArray(input, array, array.Length - 1);
}
});
}
else
{
yield return item;
}
}
}
}
[BepInPlugin("local.eclipse.cursecatcher", "CurseCatcher", "0.3.2")]
internal class Plugin : BaseUnityPlugin
{
internal interface IPatch
{
object GetDamageType(DamageInfo info);
}
private class Hopoo : IPatch
{
[HarmonyPatch(typeof(HealthComponent), "TakeDamage")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> Transpile(IEnumerable<CodeInstruction> IL)
{
return InsertCodeInstruction(IL);
}
public object GetDamageType(DamageInfo info)
{
return typeof(DamageInfo).GetField("damageType").GetValue(info);
}
}
private class Gearbox : IPatch
{
[HarmonyPatch(typeof(HealthComponent), "TakeDamageProcess")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> Transpile(IEnumerable<CodeInstruction> IL)
{
return InsertCodeInstruction(IL);
}
public object GetDamageType(DamageInfo info)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//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_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected I4, but got Unknown
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
DamageType damageType = info.damageType.damageType;
if ((int)damageType != 0)
{
return damageType;
}
return (uint)(int)info.damageType.damageTypeExtended;
}
}
public const string identifier = "local.eclipse.cursecatcher";
public const string version = "0.3.2";
private static bool artifact;
private static ConfigEntry<bool> self;
private static ConfigEntry<bool> friendly;
private static ConfigEntry<bool> fall;
private static ConfigEntry<bool> interactable;
private static ConfigEntry<bool> hazard;
private static ConfigEntry<bool> log;
internal static IPatch instance;
protected void Awake()
{
self = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Self Damage", false, "Abilities that cost health to activate will curse the player if this setting is enabled.");
friendly = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Friendly Fire", true, "Effects that damage allies may apply curse when enabled.");
fall = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Fall Damage", true, "Inflict curse upon taking sufficient fall damage.");
interactable = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Interactable Cost", true, "Whether the debuff is triggered upon paying health costs.");
hazard = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Neutral Hazards", true, "If neutral damage, such as stage hazards, can cause curse.");
artifact = ((BaseUnityPlugin)this).Config.Bind<bool>("Other", "Artifact Enabled", false, "Used to toggle the above functionality. Selectable in the Eclipse lobby, but also applies the modifier to other game modes.").Value;
log = ((BaseUnityPlugin)this).Config.Bind<bool>("Other", "Detailed Logging", false, "For troubleshooting purposes only.");
if (artifact)
{
Harmony.CreateAndPatchAll(typeof(Artifact), (string)null);
RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, new Action(CheckVersion));
return;
}
RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, (Action)delegate
{
CheckVersion();
Harmony.CreateAndPatchAll(instance.GetType(), (string)null);
});
}
private void CheckVersion()
{
IPatch patch2;
if (!Version.TryParse(RoR2Application.GetBuildId(), out Version result) || !(result < new Version(1, 3)))
{
IPatch patch = new Gearbox();
patch2 = patch;
}
else
{
IPatch patch = new Hopoo();
patch2 = patch;
}
instance = patch2;
}
private static IEnumerable<CodeInstruction> InsertCodeInstruction(IEnumerable<CodeInstruction> IL)
{
MethodInfo getSelectedDifficulty = typeof(Run).GetProperty("selectedDifficulty").GetMethod;
bool found = false;
CodeInstruction previousInstruction = null;
Console.WriteLine("Installing hook for 'Eclipse 8' curse...");
Label? label = default(Label?);
foreach (CodeInstruction instruction in IL)
{
if (found && CodeInstructionExtensions.Branches(instruction, ref label))
{
found = false;
if (CodeInstructionExtensions.LoadsConstant(previousInstruction, (Enum)(object)(DifficultyIndex)10))
{
Console.WriteLine("...instruction sequence found.");
yield return new CodeInstruction(OpCodes.Pop, (object)null);
yield return new CodeInstruction(OpCodes.Ldarg_1, (object)null);
yield return CodeInstruction.Call(typeof(Plugin), "ApplyCurse", (Type[])null, (Type[])null);
yield return new CodeInstruction(OpCodes.Brfalse, instruction.operand);
continue;
}
}
else if (CodeInstructionExtensions.Calls(instruction, getSelectedDifficulty))
{
found = true;
}
previousInstruction = instruction;
yield return instruction;
}
}
public static bool ApplyCurse(DifficultyIndex difficulty, DamageInfo damageInfo)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Invalid comparison between Unknown and I4
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Invalid comparison between Unknown and I4
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: 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)
//IL_004b: Invalid comparison between Unknown and I4
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Invalid comparison between Unknown and I4
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
if (!artifact && (int)difficulty < 10)
{
return false;
}
bool flag = true;
if (log.Value)
{
PrintInfo(damageInfo);
}
if (damageInfo.attacker == null)
{
object damageType = instance.GetDamageType(damageInfo);
if (damageType is DamageType val)
{
if ((int)val == 1 || (int)val == 3)
{
goto IL_006a;
}
if (((Enum)val).HasFlag((Enum)(object)(DamageType)2097152))
{
flag = fall.Value;
}
}
else if (damageType is uint && (uint)damageType == 134217728)
{
goto IL_006a;
}
}
else if (Object.op_Implicit((Object)(object)damageInfo.attacker))
{
TeamComponent component = damageInfo.attacker.GetComponent<TeamComponent>();
if (Object.op_Implicit((Object)(object)component))
{
TeamIndex teamIndex = component.teamIndex;
if ((int)teamIndex != 0)
{
if ((int)teamIndex == 1)
{
flag = friendly.Value;
}
}
else
{
flag = hazard.Value;
}
}
else if (damageInfo.attacker.GetComponent<IInteractable>() != null)
{
flag = interactable.Value;
}
}
goto IL_0102;
IL_0102:
if (flag)
{
return true;
}
if (log.Value)
{
Console.WriteLine("...preventing curse.");
}
return false;
IL_006a:
flag = self.Value;
goto IL_0102;
}
private static void PrintInfo(DamageInfo damage)
{
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: 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)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
string text = getName(damage.attacker);
string text2 = getName(damage.inflictor);
string text3 = "attacker: " + text;
if (text2 != text && damage.inflictor != null)
{
text3 = text3 + " (" + text2 + ")";
}
if ((Object)(object)damage.attacker != (Object)null)
{
TeamComponent component = damage.attacker.GetComponent<TeamComponent>();
if ((Object)(object)component != (Object)null)
{
string text4 = text3;
TeamIndex teamIndex = component.teamIndex;
text3 = text4 + ", team: " + ((object)(TeamIndex)(ref teamIndex)).ToString();
}
}
string text5 = text3;
DamageTypeCombo damageType = damage.damageType;
text3 = text5 + ", type: " + ((object)(DamageTypeCombo)(ref damageType)).ToString();
Console.WriteLine(text3);
static string getName(GameObject obj)
{
string text6 = ((obj == null) ? "null" : (((Object)(object)obj == (Object)null) ? "destroyed" : ((((Object)obj).name != null) ? ((Object)obj).name : "unknown")));
int num = text6.IndexOf('(');
int num2 = text6.IndexOf(')') - num + 1;
if (num >= 0 && num2 >= 0)
{
text6 = text6.Remove(num, num2);
}
return text6;
}
}
}
}
