#define DEBUG
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 R2API;
using R2API.Utils;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.Projectile;
using UnityEngine;
using UnityEngine.AddressableAssets;
[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("StickyTweaks")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+81a73fd425895e8c1d8b3242524a824932503ebe")]
[assembly: AssemblyProduct("StickyTweaks")]
[assembly: AssemblyTitle("StickyTweaks")]
[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 StickyTweaks
{
internal static class Log
{
private static ManualLogSource _logSource;
internal static void Init(ManualLogSource logSource)
{
_logSource = logSource;
}
[Conditional("DEBUG")]
internal static void Debug(object data)
{
_logSource.LogDebug(data);
}
internal static void Error(object data)
{
_logSource.LogError(data);
}
internal static void Fatal(object data)
{
_logSource.LogFatal(data);
}
internal static void Info(object data)
{
_logSource.LogInfo(data);
}
internal static void Message(object data)
{
_logSource.LogMessage(data);
}
internal static void Warning(object data)
{
_logSource.LogWarning(data);
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("Braquen.Sticky_Tweaks", "Sticky_Tweaks", "1.0.1")]
[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
public class Main : BaseUnityPlugin
{
[CompilerGenerated]
private static class <>O
{
public static Manipulator <0>__GlobalEventManager_ProcessHitEnemy;
public static Action<ProjectileManager, GameObject, Vector3, Quaternion, GameObject, float, float, bool, DamageColorIndex, GameObject, float, DamageInfo> <1>__FireModifiedStickyBomb;
public static Func<DamageInfo, bool> <2>__CheckHitEnemyProc;
public static Func<float, float> <3>__InjectProcChance;
}
public const string PluginGUID = "Braquen.Sticky_Tweaks";
public const string PluginAuthor = "Braquen";
public const string PluginName = "Sticky_Tweaks";
public const string PluginVersion = "1.0.1";
public static PluginInfo pluginInfo;
public static AssetBundle AssetBundle;
public static ConfigEntry<float> Damage;
public static ConfigEntry<float> ProcChance;
public static ConfigEntry<float> ProcCoefficient;
public static ConfigEntry<bool> OnHitAll;
private static float DamageCoefficient;
private GameObject StickyBombPrefab;
private static ProjectileImpactExplosion StickyExplosion;
public static ModdedProcType StickyProc = ProcTypeAPI.ReserveProcType();
public void Awake()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Expected O, but got Unknown
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: 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_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Expected O, but got Unknown
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Expected O, but got Unknown
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Expected O, but got Unknown
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Expected O, but got Unknown
//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
//IL_0127: Expected O, but got Unknown
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_012c: Expected O, but got Unknown
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
//IL_0157: Expected O, but got Unknown
//IL_0168: 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_0183: Unknown result type (might be due to invalid IL or missing references)
//IL_0188: Unknown result type (might be due to invalid IL or missing references)
//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
//IL_02cf: Expected O, but got Unknown
//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
//IL_02b8: Expected O, but got Unknown
Log.Init(((BaseUnityPlugin)this).Logger);
pluginInfo = ((BaseUnityPlugin)this).Info;
ConfigFile val = new ConfigFile(Path.Combine(Paths.ConfigPath, "braquen-stickytweaks.cfg"), true);
Damage = val.Bind<float>("Stats", "Damage", 1.8f, "Sticky Bomb's damage multiplier.");
ModSettingsManager.AddOption((BaseOption)new StepSliderOption(Damage, new StepSliderConfig
{
min = 0.1f,
max = 18f,
increment = 0.05f
}));
ProcChance = val.Bind<float>("Stats", "Proc Chance", 5f, "Sticky Bomb's chance to proc on hit.");
ModSettingsManager.AddOption((BaseOption)new StepSliderOption(ProcChance, new StepSliderConfig
{
min = 1f,
max = 300f,
increment = 0.5f
}));
ProcCoefficient = val.Bind<float>("Extra Functionality", "Proc Coefficient", 0.5f, "Sticky Bomb's proc coefficient. Set 0 to restore base game functionality.");
ModSettingsManager.AddOption((BaseOption)new StepSliderOption(ProcCoefficient, new StepSliderConfig
{
min = 0f,
max = 10f,
increment = 0.1f
}));
OnHitAll = val.Bind<bool>("Extra Functionality", "Stick Anything", false, "Allows Sticky Bomb to proc when hitting anything, similar to Behemoth or Overloading Elite bombs.");
ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(OnHitAll));
ModSettingsManager.SetModDescription("Tweaks sticky bomb to give it more potential for synergy.");
Sprite modIcon = Addressables.LoadAssetAsync<Sprite>((object)"RoR2/Base/StickyBomb/texStickyBombIcon.png").WaitForCompletion();
ModSettingsManager.SetModIcon(modIcon);
StickyBombPrefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/StickyBomb/StickyBomb.prefab").WaitForCompletion();
ProjectileController component = StickyBombPrefab.GetComponent<ProjectileController>();
component.procCoefficient = 1f;
StickyExplosion = StickyBombPrefab.GetComponent<ProjectileImpactExplosion>();
((ProjectileExplosion)StickyExplosion).blastProcCoefficient = ProcCoefficient.Value;
ProcCoefficient.SettingChanged += delegate
{
((ProjectileExplosion)StickyExplosion).blastProcCoefficient = ProcCoefficient.Value;
};
DamageCoefficient = Damage.Value / 1.8f;
Damage.SettingChanged += delegate
{
DamageCoefficient = Damage.Value / 1.8f;
};
Damage.SettingChanged += delegate
{
UpdateText();
};
ProcChance.SettingChanged += delegate
{
UpdateText();
};
ProcCoefficient.SettingChanged += delegate
{
UpdateText();
};
OnHitAll.SettingChanged += delegate
{
UpdateText();
};
UpdateText();
object obj = <>O.<0>__GlobalEventManager_ProcessHitEnemy;
if (obj == null)
{
Manipulator val2 = GlobalEventManager_ProcessHitEnemy;
<>O.<0>__GlobalEventManager_ProcessHitEnemy = val2;
obj = (object)val2;
}
GlobalEventManager.ProcessHitEnemy += (Manipulator)obj;
GlobalEventManager.OnHitAllProcess += new hook_OnHitAllProcess(GlobalEventManager_OnHitAllProcess);
}
private static void GlobalEventManager_ProcessHitEnemy(ILContext il)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_0195: Unknown result type (might be due to invalid IL or missing references)
//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
Log.Debug("Changing proc chain mask");
try
{
val.GotoNext((MoveType)0, new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchLdstr(x, "Prefabs/Projectiles/StickyBomb")
});
val.GotoNext((MoveType)0, new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<ProjectileManager>(x, "FireProjectileWithoutDamageType")
});
Log.Debug("Replacing fire projectile call");
val.Next.OpCode = OpCodes.Ldarg_1;
int index = val.Index;
val.Index = index + 1;
val.EmitDelegate<Action<ProjectileManager, GameObject, Vector3, Quaternion, GameObject, float, float, bool, DamageColorIndex, GameObject, float, DamageInfo>>((Action<ProjectileManager, GameObject, Vector3, Quaternion, GameObject, float, float, bool, DamageColorIndex, GameObject, float, DamageInfo>)FireModifiedStickyBomb);
index = val.Index;
val.Index = index - 1;
val.MarkLabel();
}
catch (Exception e)
{
ErrorHookFailed("Add Sticky to mask", e);
return;
}
Log.Debug("Adding Procchain conditional");
try
{
ILLabel stickyConditional = null;
Log.Debug("Locating sticky bomb if-block");
val.GotoPrev((MoveType)0, new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<Inventory>(x, "GetItemCountEffective")
});
Log.Debug("GetItemCount call found");
val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchBle(x, ref stickyConditional)
});
Log.Debug("Sticky bomb condition block end found");
Log.Debug("Adding procchain max condition");
Log.Debug(stickyConditional.Target);
val.Emit(OpCodes.Ldarg_1);
val.EmitDelegate<Func<DamageInfo, bool>>((Func<DamageInfo, bool>)CheckHitEnemyProc);
val.Emit(OpCodes.Brtrue, (object)stickyConditional);
Log.Debug("Proc condition added, now adding new proc chance");
val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 5f)
});
Log.Debug("Old proc chance found");
val.EmitDelegate<Func<float, float>>((Func<float, float>)InjectProcChance);
Log.Debug("Added new proc chance");
}
catch (Exception e2)
{
ErrorHookFailed("Check for sticky proc", e2);
}
}
private static bool CheckHitEnemyProc(DamageInfo info)
{
//IL_000e: 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)
return OnHitAll.Value || ProcTypeAPI.HasModdedProc(info.procChainMask, StickyProc);
}
private static float InjectProcChance(float ogChance)
{
return ProcChance.Value;
}
private static void FireModifiedStickyBomb(ProjectileManager instance, GameObject prefab, Vector3 pos, Quaternion rot, GameObject owner, float damage, float force, bool crit, DamageColorIndex col, GameObject target, float speedOverride, DamageInfo info)
{
//IL_0003: 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_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_001c: 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_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: 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_0095: Unknown result type (might be due to invalid IL or missing references)
FireProjectileInfo val = default(FireProjectileInfo);
val.projectilePrefab = prefab;
val.position = pos;
val.rotation = rot;
val.owner = owner;
val.damage = damage * DamageCoefficient;
val.force = force;
val.crit = crit;
val.damageColorIndex = col;
val.target = target;
((FireProjectileInfo)(ref val)).speedOverride = speedOverride;
((FireProjectileInfo)(ref val)).fuseOverride = -1f;
val.procChainMask = info.procChainMask;
ProcTypeAPI.AddModdedProc(ref val.procChainMask, StickyProc);
instance.FireProjectile(val);
}
internal static void ErrorHookFailed(string name, Exception e)
{
Log.Error(name + " hook failed: " + e.Message);
}
private void GlobalEventManager_OnHitAllProcess(orig_OnHitAllProcess orig, GlobalEventManager self, DamageInfo damageInfo, GameObject hitObject)
{
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_0112: Unknown result type (might be due to invalid IL or missing references)
//IL_011c: Unknown result type (might be due to invalid IL or missing references)
//IL_0121: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Unknown result type (might be due to invalid IL or missing references)
//IL_013d: Unknown result type (might be due to invalid IL or missing references)
//IL_0142: Unknown result type (might be due to invalid IL or missing references)
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_0135: Unknown result type (might be due to invalid IL or missing references)
//IL_0149: Unknown result type (might be due to invalid IL or missing references)
//IL_0164: Unknown result type (might be due to invalid IL or missing references)
//IL_0166: Unknown result type (might be due to invalid IL or missing references)
//IL_015d: 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_0198: Unknown result type (might be due to invalid IL or missing references)
//IL_019a: Unknown result type (might be due to invalid IL or missing references)
orig.Invoke(self, damageInfo, hitObject);
if (!OnHitAll.Value || damageInfo.procCoefficient == 0f || damageInfo.rejected || !Object.op_Implicit((Object)(object)damageInfo.attacker))
{
return;
}
CharacterBody component = damageInfo.attacker.GetComponent<CharacterBody>();
if (!Object.op_Implicit((Object)(object)component))
{
return;
}
CharacterMaster master = component.master;
if (!Object.op_Implicit((Object)(object)master))
{
return;
}
Inventory inventory = master.inventory;
if (!Object.op_Implicit((Object)(object)master.inventory))
{
return;
}
CharacterBody component2 = hitObject.GetComponent<CharacterBody>();
if (!ProcTypeAPI.HasModdedProc(damageInfo.procChainMask, StickyProc))
{
int itemCountEffective = inventory.GetItemCountEffective(Items.StickyBomb);
if (itemCountEffective > 0 && Util.CheckRoll(ProcChance.Value * (float)itemCountEffective * damageInfo.procCoefficient, master))
{
Vector3 val = damageInfo.position + 0.1f * Vector3.upVector;
Vector3 val2 = (Object.op_Implicit((Object)(object)component2) ? (component2.corePosition - val) : Vector3.zero);
float magnitude = ((Vector3)(ref val2)).magnitude;
Quaternion rot = ((magnitude != 0f) ? Util.QuaternionSafeLookRotation(val2) : Random.rotationUniform);
float num = 1.8f;
float damage = Util.OnHitProcDamage(damageInfo.damage, component.damage, num);
FireModifiedStickyBomb(ProjectileManager.instance, LegacyResourcesAPI.Load<GameObject>("Prefabs/Projectiles/StickyBomb"), val, rot, damageInfo.attacker, damage, 100f, damageInfo.crit, (DamageColorIndex)3, null, -1f, damageInfo);
}
}
}
private void UpdateText()
{
string token = "ITEM_STICKYBOMB_DESC";
string newtext = "<style=cIsDamage>" + ProcChance.Value + "%</style> <style=cStack>(+" + ProcChance.Value + "% per stack)</style> chance on hit to attach a <style=cIsDamage>bomb</style>" + (OnHitAll.Value ? "" : " to an enemy") + ", detonating for <style=cIsDamage>" + Damage.Value * 100f + "%</style> TOTAL damage.";
string token2 = "ITEM_STICKYBOMB_PICKUP";
string text = "Chance on hit to attach a bomb to enemies";
text += (OnHitAll.Value ? " and terrain." : ".");
ReplaceString(token, newtext);
ReplaceString(token2, text);
}
private void ReplaceString(string token, string newtext)
{
LanguageAPI.Add(token, newtext);
}
}
}
