using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using IL.RoR2;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using On.RoR2;
using RoR2;
using RoR2.Projectile;
using UncappedChances.Effects;
using UnityEngine;
using UnityEngine.Networking;
[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.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("UncappedChances")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+ac568060a64e68fa64ed2214b28e7ed427059e79")]
[assembly: AssemblyProduct("UncappedChances")]
[assembly: AssemblyTitle("UncappedChances")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace UncappedChances
{
public static class Configs
{
public static ConfigFile ModConfig;
private const string Section_Crit = "Crit";
private const string Section_Bleed = "Bleed";
private const string Section_Collapse = "Collapse";
private const string Section_Ghors = "Ghors Tome";
private const string Section_Sticky = "Sticky Bomb";
private const string Label_EnableChange = "Enable Changes";
private const string Desc_Enable = "Enables changes for this item.";
public static string ConfigFolderPath => Path.Combine(Paths.ConfigPath, MainPlugin.pluginInfo.Metadata.GUID);
public static void Setup()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
ModConfig = new ConfigFile(Path.Combine(ConfigFolderPath, "ModConfig.cfg"), true);
Read_AllConfigs();
}
private static void Read_AllConfigs()
{
Crit.Enable = ModConfig.Bind<bool>("Crit", "Enable Changes", Crit.EnableDefault, "Enables changes for this item.").Value;
Crit.HarderSuccessive = ModConfig.Bind<bool>("Crit", "Lower Successive Crits", Crit.HarderSuccessiveDefault, "Each successive crit has a low chance to proc.").Value;
Crit.MultiplicativeCrit = ModConfig.Bind<bool>("Crit", "Multiplicative Crits", Crit.MultiplicativeCritDefault, "Each crit multiplies the previous, ie 2-4-8 instead of 2-4-6").Value;
Bleed.Enable = ModConfig.Bind<bool>("Bleed", "Enable Changes", Bleed.EnableDefault, "Enables changes for this item.").Value;
Bleed.HarderSuccessive = ModConfig.Bind<bool>("Bleed", "Lower Successive Stacks", Bleed.HarderSuccessiveDefault, "Each successive bleed stack has a low chance to proc.").Value;
Collapse.Enable = ModConfig.Bind<bool>("Collapse", "Enable Changes", Collapse.EnableDefault, "Enables changes for this item.").Value;
Collapse.HarderSuccessive = ModConfig.Bind<bool>("Collapse", "Lower Successive Stacks", Collapse.HarderSuccessiveDefault, "Each successive collapse stack has a low chance to proc.").Value;
GhorsTome.Enable = ModConfig.Bind<bool>("Ghors Tome", "Enable Changes", GhorsTome.EnableDefault, "Enables changes for this item.").Value;
GhorsTome.HarderSuccessive = ModConfig.Bind<bool>("Ghors Tome", "Lower Successive Drops", GhorsTome.HarderSuccessiveDefault, "Each successive drop has a low chance to proc.").Value;
StickyBomb.Enable = ModConfig.Bind<bool>("Sticky Bomb", "Enable Changes", StickyBomb.EnableDefault, "Enables changes for this item.").Value;
StickyBomb.HarderSuccessive = ModConfig.Bind<bool>("Sticky Bomb", "Lower Successive Bombs", StickyBomb.HarderSuccessiveDefault, "Each successive sticky bomb has a low chance to proc.").Value;
StickyBomb.SingleBomb = ModConfig.Bind<bool>("Sticky Bomb", "One Bomb", StickyBomb.SingleBombDefault, "Instead of applying multiple bombs, apply 1 with the total damage.").Value;
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("ZetaDaemon.UncappedChances", "UncappedChances", "1.1.0")]
public class MainPlugin : BaseUnityPlugin
{
public const string PluginGUID = "ZetaDaemon.UncappedChances";
public const string PluginAuthor = "ZetaDaemon";
public const string PluginName = "UncappedChances";
public const string PluginVersion = "1.1.0";
internal static ManualLogSource ModLogger;
public static PluginInfo pluginInfo;
private void Awake()
{
ModLogger = ((BaseUnityPlugin)this).Logger;
pluginInfo = ((BaseUnityPlugin)this).Info;
Configs.Setup();
EnableChanges();
SharedHooks.Setup();
}
private void EnableChanges()
{
new Crit();
new Bleed();
new Collapse();
new GhorsTome();
new StickyBomb();
}
}
public class SharedHooks
{
public delegate void Handle_GlobalHitEvent(GameObject victim, CharacterBody attackerBody, DamageInfo damageInfo);
[CompilerGenerated]
private static class <>O
{
public static hook_OnHitEnemy <0>__GlobalEventManager_HitEnemy;
}
public static Handle_GlobalHitEvent Handle_GlobalHitEvent_Actions;
public static void Setup()
{
//IL_001e: 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_0029: Expected O, but got Unknown
if (Handle_GlobalHitEvent_Actions != null)
{
object obj = <>O.<0>__GlobalEventManager_HitEnemy;
if (obj == null)
{
hook_OnHitEnemy val = GlobalEventManager_HitEnemy;
<>O.<0>__GlobalEventManager_HitEnemy = val;
obj = (object)val;
}
GlobalEventManager.OnHitEnemy += (hook_OnHitEnemy)obj;
}
}
internal static void GlobalEventManager_HitEnemy(orig_OnHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
{
orig.Invoke(self, damageInfo, victim);
if (NetworkServer.active && Object.op_Implicit((Object)(object)victim) && Object.op_Implicit((Object)(object)damageInfo.attacker))
{
CharacterBody component = damageInfo.attacker.GetComponent<CharacterBody>();
if (Object.op_Implicit((Object)(object)component))
{
Handle_GlobalHitEvent_Actions(victim, component, damageInfo);
}
}
}
}
}
namespace UncappedChances.Effects
{
public class Bleed
{
internal static bool EnableDefault = true;
internal static bool HarderSuccessiveDefault = false;
internal static bool Enable = EnableDefault;
internal static bool HarderSuccessive = HarderSuccessiveDefault;
public Bleed()
{
if (Enable)
{
Hooks();
}
}
private void Hooks()
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Expected O, but got Unknown
MainPlugin.ModLogger.LogInfo((object)"Applying Bleed IL modifications");
SharedHooks.Handle_GlobalHitEvent_Actions = (SharedHooks.Handle_GlobalHitEvent)Delegate.Combine(SharedHooks.Handle_GlobalHitEvent_Actions, new SharedHooks.Handle_GlobalHitEvent(GlobalEventManager_HitEnemy));
GlobalEventManager.OnHitEnemy += new Manipulator(IL_OnHitEnemy);
}
private void IL_OnHitEnemy(ILContext il)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_014e: 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)
ILCursor val = new ILCursor(il);
ILLabel val2 = default(ILLabel);
if (!val.TryGotoNext(new Func<Instruction, bool>[8]
{
(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 22),
(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 1),
(Instruction x) => ILPatternMatchingExt.MatchCallvirt(x, typeof(CharacterBody), "get_bleedChance"),
(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0f),
(Instruction x) => ILPatternMatchingExt.MatchCgt(x),
(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 22),
(Instruction x) => ILPatternMatchingExt.MatchOr(x),
(Instruction x) => ILPatternMatchingExt.MatchBrfalse(x, ref val2)
}))
{
MainPlugin.ModLogger.LogError((object)"Bleed - IL Hook Failed");
return;
}
val.Index += 7;
val.Emit(OpCodes.Pop);
val.Emit(OpCodes.Ldc_I4_0);
}
private static void ApplyBleed(CharacterBody attacker, GameObject victim, DamageInfo damageInfo, uint? maxStacksFromAttacker = null)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
ProcChainMask procChainMask = damageInfo.procChainMask;
((ProcChainMask)(ref procChainMask)).AddProc((ProcType)5);
DotController.InflictDot(victim, damageInfo.attacker, (DotIndex)0, 3f * damageInfo.procCoefficient, 1f, maxStacksFromAttacker);
}
private void GlobalEventManager_HitEnemy(GameObject victim, CharacterBody attackerBody, DamageInfo damageInfo)
{
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Invalid comparison between Unknown and I4
if (((ProcChainMask)(ref damageInfo.procChainMask)).HasProc((ProcType)5))
{
return;
}
uint? maxStacksFromAttacker = null;
if (Object.op_Implicit((Object)(object)damageInfo?.inflictor))
{
ProjectileDamage component = damageInfo.inflictor.GetComponent<ProjectileDamage>();
if (Object.op_Implicit((Object)(object)component) && component.useDotMaxStacksFromAttacker)
{
maxStacksFromAttacker = component.dotMaxStacksFromAttacker;
}
}
float num = attackerBody.bleedChance * damageInfo.procCoefficient;
if ((damageInfo.damageType & 0x400) > 0)
{
ApplyBleed(attackerBody, victim, damageInfo, maxStacksFromAttacker);
}
if (!Object.op_Implicit((Object)(object)attackerBody.inventory))
{
return;
}
if (attackerBody.inventory.GetItemCount(Items.BleedOnHitAndExplode) > 0 && damageInfo.crit)
{
ApplyBleed(attackerBody, victim, damageInfo, maxStacksFromAttacker);
}
float num2 = 1f;
while (num > 0f)
{
if (Util.CheckRoll(num / num2, attackerBody.master))
{
ApplyBleed(attackerBody, victim, damageInfo, maxStacksFromAttacker);
}
num -= num2 * 100f;
if (HarderSuccessive)
{
num2 += 1f;
}
}
}
}
public class Collapse
{
internal static bool EnableDefault = true;
internal static bool HarderSuccessiveDefault = false;
internal static bool Enable = EnableDefault;
internal static bool HarderSuccessive = HarderSuccessiveDefault;
public Collapse()
{
if (Enable)
{
Hooks();
}
}
private void Hooks()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
MainPlugin.ModLogger.LogInfo((object)"Applying Collapse IL modifications");
GlobalEventManager.OnHitEnemy += new Manipulator(IL_OnHitEnemy);
}
private void IL_OnHitEnemy(ILContext il)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: 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)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
if (!val.TryGotoNext(new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.DLC1Content/Items", "BleedOnHitVoid")
}))
{
MainPlugin.ModLogger.LogError((object)"Collapse - IL Hook Failed");
return;
}
val.Index += 13;
val.Emit(OpCodes.Ldloc_1);
val.Emit(OpCodes.Ldarg_2);
val.Emit(OpCodes.Ldloc, 24);
val.Emit(OpCodes.Ldarg_1);
val.Emit(OpCodes.Ldloc_0);
val.EmitDelegate<Action<CharacterBody, GameObject, int, DamageInfo, uint?>>((Action<CharacterBody, GameObject, int, DamageInfo, uint?>)delegate(CharacterBody attackerBody, GameObject victim, int stacks, DamageInfo damageInfo, uint? maxStacksFromAttacker)
{
float num = (float)stacks * 10f * damageInfo.procCoefficient;
float num2 = 1f;
while (num > 0f)
{
if (Util.CheckRoll(num / num2, attackerBody.master))
{
ApplyCollapse(victim, damageInfo, maxStacksFromAttacker);
}
num -= num2 * 100f;
if (HarderSuccessive)
{
num2 += 1f;
}
}
});
val.Index += 1;
val.Emit(OpCodes.Pop);
val.Emit(OpCodes.Ldc_I4_0);
}
private static void ApplyCollapse(GameObject victim, DamageInfo damageInfo, uint? maxStacksFromAttacker = null)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
ProcChainMask procChainMask = damageInfo.procChainMask;
((ProcChainMask)(ref procChainMask)).AddProc((ProcType)5);
DotDef dotDef = DotController.GetDotDef((DotIndex)8);
DotController.InflictDot(victim, damageInfo.attacker, (DotIndex)8, dotDef.interval, 1f, maxStacksFromAttacker);
}
}
public class Crit
{
internal static bool EnableDefault = true;
internal static bool HarderSuccessiveDefault = false;
internal static bool MultiplicativeCritDefault = true;
internal static bool Enable = EnableDefault;
internal static bool HarderSuccessive = HarderSuccessiveDefault;
internal static bool MultiplicativeCrit = MultiplicativeCritDefault;
public Crit()
{
if (Enable)
{
Hooks();
}
}
private void Hooks()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
MainPlugin.ModLogger.LogInfo((object)"Applying Crit IL modifications");
HealthComponent.TakeDamage += new Manipulator(IL_TakeDamage);
}
private void IL_TakeDamage(ILContext il)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_00e8: 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)
ILCursor val = new ILCursor(il);
if (!val.TryGotoNext(new Func<Instruction, bool>[5]
{
(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 6),
(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 1),
(Instruction x) => ILPatternMatchingExt.MatchCallvirt(x, typeof(CharacterBody), "get_critMultiplier"),
(Instruction x) => ILPatternMatchingExt.MatchMul(x),
(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 6)
}))
{
MainPlugin.ModLogger.LogError((object)"Crit - IL Hook Failed");
return;
}
val.Index += 3;
val.Emit(OpCodes.Pop);
val.Emit(OpCodes.Ldloc_1);
val.EmitDelegate<Func<CharacterBody, float>>((Func<CharacterBody, float>)delegate(CharacterBody body)
{
float num = 1f;
float num2 = body.crit - 100f;
float num3 = body.critMultiplier;
while (num2 > 0f)
{
if (HarderSuccessive)
{
num += 1f;
}
if (Util.CheckRoll(num2 / num, body.master))
{
num3 = ((!MultiplicativeCrit) ? (num3 + body.critMultiplier) : (num3 * body.critMultiplier));
}
num2 -= num * 100f;
}
return num3;
});
}
}
public class GhorsTome
{
internal static bool EnableDefault = true;
internal static bool HarderSuccessiveDefault = false;
internal static bool Enable = EnableDefault;
internal static bool HarderSuccessive = HarderSuccessiveDefault;
public GhorsTome()
{
if (Enable)
{
Hooks();
}
}
private void Hooks()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
MainPlugin.ModLogger.LogInfo((object)"Applying Ghors IL modifications");
GlobalEventManager.OnCharacterDeath += new Manipulator(IL_OnCharacterDeath);
}
private void IL_OnCharacterDeath(ILContext il)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_0063: 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_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
if (!val.TryGotoNext(new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "BonusGoldPackOnKill")
}))
{
MainPlugin.ModLogger.LogError((object)"Ghors - IL Hook Failed");
return;
}
val.Index += 3;
val.Emit(OpCodes.Ldloc, 16);
val.Emit(OpCodes.Ldloc, 85);
val.Emit(OpCodes.Ldloc, 6);
val.Emit(OpCodes.Ldloc, 18);
val.EmitDelegate<Action<CharacterMaster, int, Vector3, TeamIndex>>((Action<CharacterMaster, int, Vector3, TeamIndex>)delegate(CharacterMaster attackerMaster, int stacks, Vector3 vector, TeamIndex attackerTeamIndex)
{
//IL_002b: 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_004f: Unknown result type (might be due to invalid IL or missing references)
float num = 1f;
float num2 = 4f * (float)stacks;
while (num2 > 0f)
{
if (Util.CheckRoll(num2 / num, attackerMaster))
{
GameObject val2 = Object.Instantiate<GameObject>(LegacyResourcesAPI.Load<GameObject>("Prefabs/NetworkedObjects/BonusMoneyPack"), vector, Random.rotation);
TeamFilter component = val2.GetComponent<TeamFilter>();
if (Object.op_Implicit((Object)(object)component))
{
component.teamIndex = attackerTeamIndex;
}
NetworkServer.Spawn(val2);
}
num2 -= num * 100f;
if (HarderSuccessive)
{
num += 1f;
}
}
});
val.Index += 2;
val.Emit(OpCodes.Pop);
val.Emit(OpCodes.Ldc_I4_0);
}
}
public class StickyBomb
{
internal static bool EnableDefault = true;
internal static bool HarderSuccessiveDefault = false;
internal static bool SingleBombDefault = true;
internal static bool Enable = EnableDefault;
internal static bool HarderSuccessive = HarderSuccessiveDefault;
internal static bool SingleBomb = SingleBombDefault;
public StickyBomb()
{
if (Enable)
{
Hooks();
}
}
private void Hooks()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
MainPlugin.ModLogger.LogInfo((object)"Applying Sticky IL modifications");
GlobalEventManager.OnHitEnemy += new Manipulator(IL_OnHitEnemy);
}
private void IL_OnHitEnemy(ILContext il)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: 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_0089: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
if (!val.TryGotoNext(new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, "RoR2.RoR2Content/Items", "StickyBomb")
}))
{
MainPlugin.ModLogger.LogError((object)"Sticky - IL Hook Failed");
return;
}
val.Index += 3;
val.Emit(OpCodes.Ldloc_1);
val.Emit(OpCodes.Ldloc_2);
val.Emit(OpCodes.Ldloc, 14);
val.Emit(OpCodes.Ldarg_1);
val.EmitDelegate<Action<CharacterBody, CharacterBody, int, DamageInfo>>((Action<CharacterBody, CharacterBody, int, DamageInfo>)delegate(CharacterBody attackerBody, CharacterBody victimBody, int stacks, DamageInfo damageInfo)
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
//IL_0167: Unknown result type (might be due to invalid IL or missing references)
//IL_0168: Unknown result type (might be due to invalid IL or missing references)
//IL_0160: Unknown result type (might be due to invalid IL or missing references)
//IL_016d: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: Unknown result type (might be due to invalid IL or missing references)
//IL_017f: Unknown result type (might be due to invalid IL or missing references)
if (stacks > 0)
{
bool alive = victimBody.healthComponent.alive;
float num = 5f;
Vector3 position = damageInfo.position;
Vector3 val2 = victimBody.corePosition - position;
float magnitude = ((Vector3)(ref val2)).magnitude;
float num2 = 1.8f;
float num3 = Util.OnHitProcDamage(damageInfo.damage, attackerBody.damage, num2);
float num4 = (float)stacks * 5f * damageInfo.procCoefficient;
float num5 = 1f;
int num6 = 0;
while (num4 > 0f)
{
if (Util.CheckRoll(num4 / num5, attackerBody.master))
{
if (!SingleBomb)
{
Quaternion val3 = ((magnitude != 0f) ? Util.QuaternionSafeLookRotation(val2) : Random.rotationUniform);
ProjectileManager.instance.FireProjectile(LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/StickyBomb"), position, val3, damageInfo.attacker, num3, 100f, damageInfo.crit, (DamageColorIndex)3, (GameObject)null, alive ? (magnitude * num) : (-1f));
}
else
{
num6++;
}
}
num4 -= num5 * 100f;
if (HarderSuccessive)
{
num5 += 1f;
}
}
if (SingleBomb && num6 > 0)
{
Quaternion val4 = ((magnitude != 0f) ? Util.QuaternionSafeLookRotation(val2) : Random.rotationUniform);
ProjectileManager.instance.FireProjectile(LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/StickyBomb"), position, val4, damageInfo.attacker, (float)num6 * num3, 100f, damageInfo.crit, (DamageColorIndex)3, (GameObject)null, alive ? (magnitude * num) : (-1f));
}
}
});
val.Index += 1;
val.Emit(OpCodes.Pop);
val.Emit(OpCodes.Ldc_I4_0);
}
}
}
