Decompiled source of HIFUVoidFiendTweaks v1.0.3
HIFUVoidFiendTweaks.dll
Decompiled a month ago
The result has been truncated due to the large size, download it to view full contents!
using System; using System.Collections.Generic; using System.Diagnostics; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using System.Text.RegularExpressions; using BepInEx; using BepInEx.Configuration; using BepInEx.Logging; using EntityStates; using EntityStates.VoidSurvivor; using EntityStates.VoidSurvivor.CorruptMode; using EntityStates.VoidSurvivor.Weapon; using HIFUVoidFiendTweaks.Misc; using HIFUVoidFiendTweaks.Skilldefs; using HIFUVoidFiendTweaks.Skills; using HIFUVoidFiendTweaks.Utils; using HIFUVoidFiendTweaks.Utils.Assets; using HIFUVoidFiendTweaks.VFX; using HarmonyLib; using IL.EntityStates.VoidSurvivor.Weapon; using IL.RoR2; using KinematicCharacterController; using Microsoft.CodeAnalysis; using Mono.Cecil.Cil; using MonoMod.Cil; using On.EntityStates.VoidSurvivor; using On.EntityStates.VoidSurvivor.CorruptMode; using On.EntityStates.VoidSurvivor.Weapon; using On.RoR2; using R2API; using RoR2; using RoR2.Audio; using RoR2.EntitlementManagement; using RoR2.ExpansionManagement; using RoR2.Navigation; using RoR2.Projectile; using RoR2.Skills; using RoR2.UI; using TMPro; using UnityEngine; using UnityEngine.AI; using UnityEngine.AddressableAssets; using UnityEngine.Audio; 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.1", FrameworkDisplayName = ".NET Standard 2.1")] [assembly: AssemblyCompany("HIFUVoidFiendTweaks")] [assembly: AssemblyConfiguration("Debug")] [assembly: AssemblyFileVersion("1.0.0.0")] [assembly: AssemblyInformationalVersion("1.0.0+f9de7e4f5e9a2d68a4bf885078f8d21cf84a34f6")] [assembly: AssemblyProduct("HIFUVoidFiendTweaks")] [assembly: AssemblyTitle("HIFUVoidFiendTweaks")] [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 HIFUVoidFiendTweaks { public class ConfigManager { internal static bool ConfigChanged; internal static bool VersionChanged; public static T HandleConfig<T>(ConfigEntryBase entry, ConfigFile config, string name) { //IL_0087: Unknown result type (might be due to invalid IL or missing references) //IL_008d: Expected O, but got Unknown //IL_00a9: Unknown result type (might be due to invalid IL or missing references) //IL_00af: Expected O, but got Unknown //IL_00b8: Unknown result type (might be due to invalid IL or missing references) //IL_00be: Expected O, but got Unknown MethodInfo methodInfo = (from x in typeof(ConfigFile).GetMethods() where x.Name == "Bind" select x).First(); methodInfo = methodInfo.MakeGenericMethod(typeof(T)); object[] parameters = new object[3] { (object)new ConfigDefinition(Regex.Replace(config.ConfigFilePath, "\\W", "") + " : " + entry.Definition.Section, name), entry.DefaultValue, (object)new ConfigDescription(entry.Description.Description, (AcceptableValueBase)null, Array.Empty<object>()) }; ConfigEntryBase val = (ConfigEntryBase)methodInfo.Invoke(config, parameters); if (Main._preVersioning) { entry.BoxedValue = entry.DefaultValue; } if (!ConfigEqual(val.DefaultValue, val.BoxedValue) && VersionChanged) { entry.BoxedValue = entry.DefaultValue; val.BoxedValue = val.DefaultValue; } return default(T); } private static bool ConfigEqual(object a, object b) { if (a.Equals(b)) { return true; } if (float.TryParse(a.ToString(), out var result) && float.TryParse(b.ToString(), out var result2) && (double)Mathf.Abs(result - result2) < 0.0001) { return true; } return false; } } public abstract class CoolerBasicMeleeAttack : BasicMeleeAttack { public abstract float BaseDuration { get; } public abstract float DamageCoefficient { get; } public abstract string HitboxName { get; } public abstract GameObject HitEffectPrefab { get; } public abstract float ProcCoefficient { get; } public abstract float HitPauseDuration { get; } public abstract GameObject SwingEffectPrefab { get; } public abstract string MuzzleString { get; } public virtual string MechanimHitboxParameter { get; } public virtual bool ScaleHitPauseDurationWithAttackSpeed { get; } = true; public virtual Func<bool> AlternateActiveParameter { get; } = () => true; public override void OnEnter() { base.baseDuration = BaseDuration; base.damageCoefficient = DamageCoefficient; base.hitBoxGroupName = HitboxName; base.hitEffectPrefab = HitEffectPrefab; base.procCoefficient = ProcCoefficient; base.hitPauseDuration = HitPauseDuration; base.swingEffectPrefab = SwingEffectPrefab; base.swingEffectMuzzleString = MuzzleString; if (MechanimHitboxParameter != null) { base.mecanimHitboxActiveParameter = MechanimHitboxParameter; } base.scaleHitPauseDurationAndVelocityWithAttackSpeed = ScaleHitPauseDurationWithAttackSpeed; ((BasicMeleeAttack)this).OnEnter(); } public override void FixedUpdate() { ((EntityState)this).fixedAge = ((EntityState)this).fixedAge + Time.fixedDeltaTime; if (string.IsNullOrEmpty(MechanimHitboxParameter) && AlternateActiveParameter()) { ((BasicMeleeAttack)this).BeginMeleeAttackEffect(); } else if (base.animator.GetFloat(MechanimHitboxParameter) >= 0.5f) { ((BasicMeleeAttack)this).BeginMeleeAttackEffect(); } if (((EntityState)this).isAuthority) { ((BasicMeleeAttack)this).AuthorityFixedUpdate(); } } } [BepInDependency(/*Could not decode attribute arguments.*/)] [BepInDependency(/*Could not decode attribute arguments.*/)] [BepInDependency(/*Could not decode attribute arguments.*/)] [BepInPlugin("HIFU.HIFUVoidFiendTweaks", "HIFUVoidFiendTweaks", "1.0.1")] public class Main : BaseUnityPlugin { public const string PluginGUID = "HIFU.HIFUVoidFiendTweaks"; public const string PluginAuthor = "HIFU"; public const string PluginName = "HIFUVoidFiendTweaks"; public const string PluginVersion = "1.0.1"; public static ConfigFile HVFTConfig; public static ConfigFile HVFTBackupConfig; public static ManualLogSource HVFTLogger; public static bool _preVersioning; public static ConfigEntry<bool> enableAutoConfig { get; set; } public static ConfigEntry<string> latestVersion { get; set; } public void Awake() { //IL_0027: Unknown result type (might be due to invalid IL or missing references) //IL_0031: Expected O, but got Unknown //IL_0149: Unknown result type (might be due to invalid IL or missing references) //IL_014e: Unknown result type (might be due to invalid IL or missing references) //IL_0175: Unknown result type (might be due to invalid IL or missing references) //IL_017a: Unknown result type (might be due to invalid IL or missing references) //IL_018a: Unknown result type (might be due to invalid IL or missing references) //IL_018f: Unknown result type (might be due to invalid IL or missing references) //IL_0199: Unknown result type (might be due to invalid IL or missing references) //IL_019e: Unknown result type (might be due to invalid IL or missing references) HVFTLogger = ((BaseUnityPlugin)this).Logger; HVFTConfig = ((BaseUnityPlugin)this).Config; HVFTBackupConfig = new ConfigFile(Paths.ConfigPath + "\\HIFU.HIFUVoidFiendTweaks.Backup.cfg", true); HVFTBackupConfig.Bind<string>(": DO NOT MODIFY THIS FILES CONTENTS :", ": DO NOT MODIFY THIS FILES CONTENTS :", ": DO NOT MODIFY THIS FILES CONTENTS :", ": DO NOT MODIFY THIS FILES CONTENTS :"); enableAutoConfig = HVFTConfig.Bind<bool>("Config", "Enable Auto Config Sync", true, "Disabling this would stop HIFUVoidFiendTweaks from syncing config whenever a new version is found."); _preVersioning = !((Dictionary<ConfigDefinition, string>)AccessTools.DeclaredPropertyGetter(typeof(ConfigFile), "OrphanedEntries").Invoke(HVFTConfig, null)).Keys.Any((ConfigDefinition x) => x.Key == "Latest Version"); latestVersion = HVFTConfig.Bind<string>("Config", "Latest Version", "1.0.1", "DO NOT CHANGE THIS"); if (enableAutoConfig.Value && (_preVersioning || latestVersion.Value != "1.0.1")) { latestVersion.Value = "1.0.1"; ConfigManager.VersionChanged = true; HVFTLogger.LogInfo((object)"Config Autosync Enabled."); } GameObject val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSurvivor/VoidSurvivorBody.prefab").WaitForCompletion(); EntityStateMachine val2 = val.AddComponent<EntityStateMachine>(); val2.customName = "Flood"; val2.initialStateType = new SerializableEntityStateType(typeof(Idle)); val2.mainStateType = new SerializableEntityStateType(typeof(Idle)); SkillDef val3 = Addressables.LoadAssetAsync<SkillDef>((object)"RoR2/DLC1/VoidSurvivor/ChargeMegaBlaster.asset").WaitForCompletion(); val3.activationStateMachineName = "Flood"; IEnumerable<Type> enumerable = from type in Assembly.GetExecutingAssembly().GetTypes() where !type.IsAbstract && type.IsSubclassOf(typeof(TweakBase)) select type; HVFTLogger.LogInfo((object)"==+----------------==TWEAKS==----------------+=="); foreach (Type item in enumerable) { TweakBase tweakBase = (TweakBase)Activator.CreateInstance(item); if (ValidateTweak(tweakBase)) { tweakBase.Init(); } } IEnumerable<Type> enumerable2 = from type in Assembly.GetExecutingAssembly().GetTypes() where !type.IsAbstract && type.IsSubclassOf(typeof(MiscBase)) select type; HVFTLogger.LogInfo((object)"==+----------------==MISC==----------------+=="); foreach (Type item2 in enumerable2) { MiscBase miscBase = (MiscBase)Activator.CreateInstance(item2); if (ValidateMisc(miscBase)) { miscBase.Init(); } } BigTracer.Create(); CorruptedDescriptions.ChangeDescriptions(); PermeateSD.Create(); } public bool ValidateTweak(TweakBase tb) { if (tb.isEnabled && ((BaseUnityPlugin)this).Config.Bind<bool>(tb.Name, "Enable?", true, "Vanilla is false").Value) { return true; } return false; } public bool ValidateMisc(MiscBase mb) { if (mb.isEnabled && ((BaseUnityPlugin)this).Config.Bind<bool>(mb.Name, "Enable?", true, "Vanilla is false").Value) { return true; } return false; } private void WITHINDESTRUCTIONMYFUCKINGBELOVED() { } } public abstract class MiscBase { public abstract string Name { get; } public virtual bool isEnabled { get; } = true; public T ConfigOption<T>(T value, string name, string description) { ConfigEntry<T> val = Main.HVFTConfig.Bind<T>(Name, name, value, description); ConfigManager.HandleConfig<T>((ConfigEntryBase)(object)val, Main.HVFTBackupConfig, name); return val.Value; } public abstract void Hooks(); public string d(float f) { return f * 100f + "%"; } public virtual void Init() { Hooks(); Main.HVFTLogger.LogInfo((object)("Added " + Name)); } } public abstract class MiscBase<T> : MiscBase where T : MiscBase<T> { public static T instance { get; set; } public MiscBase() { if (instance != null) { throw new InvalidOperationException("Singleton class " + typeof(T).Name + " was instantiated twice"); } instance = this as T; } } public static class CorruptPermeateIcon { public static string DATA = "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"; public static Sprite GetSprite() { //IL_000e: Unknown result type (might be due to invalid IL or missing references) //IL_0014: Expected O, but got Unknown //IL_0035: 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) byte[] array = Convert.FromBase64String(DATA); Texture2D val = new Texture2D(2, 2); ImageConversion.LoadImage(val, array); return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f); } } public static class PermeateIcon { public static string DATA = "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"; public static Sprite GetSprite() { //IL_000e: Unknown result type (might be due to invalid IL or missing references) //IL_0014: Expected O, but got Unknown //IL_0035: 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) byte[] array = Convert.FromBase64String(DATA); Texture2D val = new Texture2D(2, 2); ImageConversion.LoadImage(val, array); return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f); } } public abstract class TweakBase { public abstract string Name { get; } public abstract string SkillToken { get; } public abstract string DescText { get; } public abstract bool isVoid { get; } public virtual bool isEnabled { get; } = true; public T ConfigOption<T>(T value, string name, string description) { ConfigEntry<T> val = Main.HVFTConfig.Bind<T>(Name, name, value, description); ConfigManager.HandleConfig<T>((ConfigEntryBase)(object)val, Main.HVFTBackupConfig, name); return val.Value; } public abstract void Hooks(); public string d(float f) { return f * 100f + "%"; } public virtual void Init() { Hooks(); string text = ((!isVoid) ? ("VOIDSURVIVOR_" + SkillToken.ToUpper() + "_DESCRIPTION") : ("VOIDSURVIVOR_" + SkillToken.ToUpper() + "_TOOLTIP")); LanguageAPI.Add(text, DescText); Main.HVFTLogger.LogInfo((object)("Added " + Name)); } } public abstract class TweakBase<T> : TweakBase where T : TweakBase<T> { public static T instance { get; set; } public TweakBase() { if (instance != null) { throw new InvalidOperationException("Singleton class " + typeof(T).Name + " was instantiated twice"); } instance = this as T; } } } namespace HIFUVoidFiendTweaks.VFX { public static class BigTracer { public static GameObject tracer; public static void Create() { //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_006e: Unknown result type (might be due to invalid IL or missing references) //IL_0091: Unknown result type (might be due to invalid IL or missing references) //IL_00b6: Unknown result type (might be due to invalid IL or missing references) //IL_00df: Unknown result type (might be due to invalid IL or missing references) //IL_00e4: Unknown result type (might be due to invalid IL or missing references) //IL_00f3: Unknown result type (might be due to invalid IL or missing references) tracer = PrefabAPI.InstantiateClone(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSurvivor/VoidSurvivorBeamTracer.prefab").WaitForCompletion(), "FourthBeamTracer", false); EffectComponent component = tracer.GetComponent<EffectComponent>(); component.applyScale = true; LineRenderer component2 = tracer.GetComponent<LineRenderer>(); component2.widthMultiplier = Drown.FourthRadius * 0.5f; Transform transform = tracer.transform; transform.localScale = new Vector3(Drown.FourthRadius, Drown.FourthRadius, Drown.FourthRadius); Transform child = transform.GetChild(0); child.localScale = new Vector3(Drown.FourthRadius, Drown.FourthRadius, Drown.FourthRadius); Transform child2 = transform.GetChild(1); child2.localScale = new Vector3(Drown.FourthRadius, Drown.FourthRadius, Drown.FourthRadius); ParticleSystem component3 = ((Component)child.GetChild(1)).GetComponent<ParticleSystem>(); ((Component)component3).gameObject.SetActive(true); MainModule main = component3.main; ((MainModule)(ref main)).startSize = MinMaxCurve.op_Implicit(0.15f * Drown.FourthRadius); Light component4 = ((Component)child2.GetChild(2)).GetComponent<Light>(); component4.range = 2f * Drown.FourthRadius; component4.intensity = 10f; ContentAddition.AddEffect(tracer); } } } namespace HIFUVoidFiendTweaks.Skills { public class CorruptedDrown : TweakBase { public static float Damage; public static float PPS; public override string Name => "Primary :: Corrupted Drown"; public override string SkillToken => "primary_uprade"; public override string DescText => "<style=cKeywordName>【Corruption Upgrade】</style><style=cSub>Transform into a " + d(Damage) + " damage short-range beam.</style>"; public override bool isVoid => true; public override void Init() { Damage = ConfigOption(12f, "Damage", "Decimal. Vanilla is 20"); PPS = ConfigOption(4f, "Proc Coefficient Per Second", "Vanilla is 5"); base.Init(); } public override void Hooks() { //IL_0008: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Expected O, but got Unknown FireCorruptHandBeam.OnEnter += new hook_OnEnter(FireCorruptHandBeam_OnEnter); } private void FireCorruptHandBeam_OnEnter(orig_OnEnter orig, FireCorruptHandBeam self) { self.damageCoefficientPerSecond = Damage; self.procCoefficientPerSecond = PPS; orig.Invoke(self); } } internal class CorruptedFlood : TweakBase { public static float Damage; public static float Knockback; public static float AoE; public static float ProjectileSpeed; public static float Lifetime; public static float Cooldown; public override string Name => "Secondary :: Corrupted Flood"; public override string SkillToken => "secondary_uprade"; public override string DescText => "<style=cKeywordName>【Corruption Upgrade】</style><style=cSub>Transform into a " + d(Damage) + " damage black hole that pulls enemies in an enormous radius.</style>"; public override bool isVoid => true; public override void Init() { Knockback = ConfigOption(-2500f, "Knockback", "Vanilla is 3000"); AoE = ConfigOption(25f, "Radius", "Vanilla is 10"); Damage = ConfigOption(4f, "Damage", "Decimal. Vanilla is 11"); ProjectileSpeed = ConfigOption(40f, "Projectile Speed", "Vanilla is 70"); Lifetime = ConfigOption(4f, "Projectile Duration", "Vanilla is 99"); Cooldown = ConfigOption(7.5f, "Cooldown", "Vanilla is 4"); base.Init(); } public override void Hooks() { //IL_0008: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Expected O, but got Unknown FireCorruptDisks.OnEnter += new hook_OnEnter(FireCorruptDisks_OnEnter); Changes(); } private void FireCorruptDisks_OnEnter(orig_OnEnter orig, FireCorruptDisks self) { self.damageCoefficient = Damage; orig.Invoke(self); } private void Changes() { //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_0038: Unknown result type (might be due to invalid IL or missing references) //IL_003d: Unknown result type (might be due to invalid IL or missing references) //IL_00af: Unknown result type (might be due to invalid IL or missing references) //IL_00b4: Unknown result type (might be due to invalid IL or missing references) GameObject val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSurvivor/VoidSurvivorMegaBlasterBigProjectileCorrupted.prefab").WaitForCompletion(); ProjectileSimple component = val.GetComponent<ProjectileSimple>(); component.desiredForwardSpeed = ProjectileSpeed; component.lifetime = Lifetime; component.lifetimeExpiredEffect = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSurvivor/VoidSurvivorMegaBlasterExplosionCorrupted.prefab").WaitForCompletion(); ProjectileImpactExplosion component2 = val.GetComponent<ProjectileImpactExplosion>(); ((ProjectileExplosion)component2).blastRadius = AoE; RadialForce val2 = val.AddComponent<RadialForce>(); val2.radius = AoE; val2.damping = 0.5f; val2.forceMagnitude = Knockback; val2.forceCoefficientAtEdge = 0.5f; GameObject ghostPrefab = val.GetComponent<ProjectileController>().ghostPrefab; ghostPrefab.GetComponent<ProjectileGhostController>().inheritScaleFromProjectile = true; SkillDef val3 = Addressables.LoadAssetAsync<SkillDef>((object)"RoR2/DLC1/VoidSurvivor/FireCorruptDisk.asset").WaitForCompletion(); val3.baseRechargeInterval = Cooldown; } } public class CorruptedSuppress : TweakBase { public static float SelfDamage; public static float CorruptionGain; public static int MaxCharges; public static float duration; public static float endlag; public override string Name => "Special :: Corrupted Suppress"; public override string SkillToken => "special_uprade"; public override string DescText => "<style=cKeywordName>【Corruption Upgrade】</style><style=cSub>Transform to crush " + d(SelfDamage) + " health, gaining " + CorruptionGain + "% Corruption instead. Can hold up to " + MaxCharges + " orbs.</style>"; public override bool isVoid => true; public override void Init() { SelfDamage = ConfigOption(0.19f, "Self Damage", "Decimal. Vanilla is 0.25"); MaxCharges = ConfigOption(2, "Max Charges", "Vanilla is 2"); CorruptionGain = ConfigOption(25f, "Corruption Gain", "Vanilla is 25"); duration = ConfigOption(0.8f, "Animation Duration", "Vanilla is 1"); endlag = ConfigOption(0.3f, "Endlag", "Vanilla is 1"); base.Init(); } public override void Hooks() { //IL_0008: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Expected O, but got Unknown //IL_001a: Unknown result type (might be due to invalid IL or missing references) //IL_0024: Expected O, but got Unknown CrushBase.OnEnter += new hook_OnEnter(CrushBase_OnEnter); ChargeCrushBase.OnEnter += new hook_OnEnter(ChargeCrushBase_OnEnter); Changes(); } private void ChargeCrushBase_OnEnter(orig_OnEnter orig, ChargeCrushBase self) { if (self != null) { self.baseDuration = duration; } orig.Invoke(self); } private void CrushBase_OnEnter(orig_OnEnter orig, CrushBase self) { if (self is CrushHealth) { self.selfHealFraction = 0f - SelfDamage; self.corruptionChange = CorruptionGain; self.baseDuration = endlag; } orig.Invoke(self); } private void Changes() { //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) SkillDef val = Addressables.LoadAssetAsync<SkillDef>((object)"RoR2/DLC1/VoidSurvivor/CrushHealth.asset").WaitForCompletion(); val.baseMaxStock = MaxCharges; } } public class Drown : TweakBase { public static float Damage; public static float Radius; public static int FalloffType; public static float FourthDamage; public static int FourthFalloff; public static float FourthRadius; public int faaa; public override string Name => "Primary : Drown"; public override string SkillToken => "primary"; public override string DescText => "Fire a <style=cIsUtility>slowing</style> long-range beam for <style=cIsDamage>" + d(Damage) + " damage</style>. Every fourth shot fires a medium beam for an additional <style=cIsDamage>" + d(FourthDamage) + " damage</style>."; public override bool isVoid => false; public override void Init() { Damage = ConfigOption(3f, "Damage", "Decimal. Vanilla is 3"); Radius = ConfigOption(1f, "Radius", "Vanilla is 2"); FalloffType = ConfigOption(1, "Falloff Type", "0 is None, 1 is Standard, 2 is Buckshot. Vanilla is 0"); FourthDamage = ConfigOption(1.75f, "Fourth Hit Damage", "Decimal. Default is 1.5"); FourthFalloff = ConfigOption(0, "Fourth Hit Falloff Type", "0 is None, 1 is Standard, 2 is Buckshot. Default is 0"); FourthRadius = ConfigOption(5f, "Fourth Hit Radius", "Default is 5"); base.Init(); } public override void Hooks() { //IL_0008: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Expected O, but got Unknown //IL_002c: Unknown result type (might be due to invalid IL or missing references) //IL_0036: Expected O, but got Unknown FireHandBeam.OnEnter += new hook_OnEnter(FireHandBeam_OnEnter); CharacterBody.onBodyStartGlobal += CharacterBody_onBodyStartGlobal; FireHandBeam.OnEnter += new Manipulator(FireHandBeam_OnEnter1); } private void CharacterBody_onBodyStartGlobal(CharacterBody body) { if (((Object)body).name == "VoidSurvivorBody(Clone)") { DrownFour component = ((Component)body).GetComponent<DrownFour>(); if (!Object.op_Implicit((Object)(object)component)) { ((Component)body).gameObject.AddComponent<DrownFour>(); } } } private void FireHandBeam_OnEnter1(ILContext il) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0008: Expected O, but got Unknown //IL_0066: Unknown result type (might be due to invalid IL or missing references) ILCursor val = new ILCursor(il); if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[2] { (Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 0), (Instruction x) => ILPatternMatchingExt.MatchStfld(x, typeof(BulletAttack), "falloffModel") })) { val.Remove(); val.Emit(OpCodes.Ldc_I4, faaa); } else { Main.HVFTLogger.LogError((object)"Failed to apply Drown Falloff IL Hook"); } } private void FireHandBeam_OnEnter(orig_OnEnter orig, FireHandBeam self) { self.damageCoefficient = Damage; self.bulletRadius = Radius; DrownFour component = ((Component)((EntityState)self).characterBody).GetComponent<DrownFour>(); if ((Object)(object)component != (Object)null) { component.FireCount++; } orig.Invoke(self); } public Drown() { int falloffType = FalloffType; if (1 == 0) { } int num = falloffType switch { 1 => 1, 2 => 2, _ => 0, }; if (1 == 0) { } faaa = num; base..ctor(); } } public class DrownFour : MonoBehaviour { public int FireCount; public CharacterBody body => ((Component)this).GetComponent<CharacterBody>(); private GameObject hitEffectPrefab => Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSurvivor/VoidSurvivorBeamImpact.prefab").WaitForCompletion(); public void FixedUpdate() { //IL_0036: Unknown result type (might be due to invalid IL or missing references) //IL_003d: Expected O, but got Unknown //IL_005f: Unknown result type (might be due to invalid IL or missing references) //IL_0064: 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) //IL_007b: 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_00e1: Unknown result type (might be due to invalid IL or missing references) //IL_00f1: Unknown result type (might be due to invalid IL or missing references) //IL_00f2: Unknown result type (might be due to invalid IL or missing references) //IL_0165: Unknown result type (might be due to invalid IL or missing references) //IL_016a: Unknown result type (might be due to invalid IL or missing references) //IL_0186: Unknown result type (might be due to invalid IL or missing references) //IL_018b: Unknown result type (might be due to invalid IL or missing references) //IL_00e5: Unknown result type (might be due to invalid IL or missing references) //IL_00e9: Unknown result type (might be due to invalid IL or missing references) if (FireCount >= 4 && Util.HasEffectiveAuthority(((Component)body).gameObject)) { Util.PlaySound("Play_voidman_m2_explode", ((Component)this).gameObject); BulletAttack val = new BulletAttack(); val.owner = ((Component)this).gameObject; val.weapon = ((Component)this).gameObject; val.origin = body.corePosition; Ray aimRay = body.inputBank.GetAimRay(); val.aimVector = ((Ray)(ref aimRay)).direction; val.muzzleName = "MuzzleHandBeam"; val.maxDistance = 1000f; val.minSpread = 0f; val.maxSpread = 0f; val.radius = Drown.FourthRadius; BulletAttack val2 = val; int fourthFalloff = Drown.FourthFalloff; if (1 == 0) { } FalloffModel falloffModel = (FalloffModel)(fourthFalloff switch { 1 => 1, 2 => 2, _ => 0, }); if (1 == 0) { } val2.falloffModel = falloffModel; val.smartCollision = true; val.damage = body.damage * Drown.FourthDamage; val.procCoefficient = 0f; val.force = 0f; val.isCrit = Util.CheckRoll(body.crit, body.master); val.hitEffectPrefab = hitEffectPrefab; val.stopperMask = ((LayerIndex)(ref LayerIndex.noCollision)).mask; val.bulletCount = 1u; val.tracerEffectPrefab = BigTracer.tracer; val.damageType = DamageTypeCombo.op_Implicit((DamageType)8); val.Fire(); FireCount = 0; } } } public class Permeate : CoolerBasicMeleeAttack, IStepSetter { private int step; public override float BaseDuration => 0.5f; public override float DamageCoefficient => PermeateSD.DAMAGE_COEFF; public override string HitboxName => "Melee"; public override GameObject HitEffectPrefab => GameObject.VoidSurvivorBeamImpact; public override float ProcCoefficient => 1f; public override float HitPauseDuration => 0.05f; public override GameObject SwingEffectPrefab => GameObject.VoidSurvivorMeleeSlash1; public override string MuzzleString => "MuzzleMelee"; public override string MechanimHitboxParameter => "Melee.hitBoxActive"; public override void OnEnter() { //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_0074: 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_008d: Unknown result type (might be due to invalid IL or missing references) //IL_0092: Unknown result type (might be due to invalid IL or missing references) //IL_0098: Unknown result type (might be due to invalid IL or missing references) //IL_009d: Unknown result type (might be due to invalid IL or missing references) //IL_00a2: Unknown result type (might be due to invalid IL or missing references) base.OnEnter(); int num = step; if (1 == 0) { } GameObject swingEffectPrefab = ((num != 2) ? GameObject.VoidSurvivorMeleeSlash1 : GameObject.VoidSurvivorMeleeSlash2); if (1 == 0) { } ((BasicMeleeAttack)this).swingEffectPrefab = swingEffectPrefab; ((BasicMeleeAttack)this).forceVector = Vector3.zero; ((BasicMeleeAttack)this).shorthopVelocityFromHit = 3f; if (step == 2) { ((BaseCharacterController)((EntityState)this).characterMotor).Motor.ForceUnground(0.1f); Vector3 aimDirection = ((EntityState)this).inputBank.aimDirection; aimDirection.y = 0f; CharacterMotor characterMotor = ((EntityState)this).characterMotor; characterMotor.velocity += aimDirection * PermeateSD.LUNGE_DISTANCE; } } public override void PlayAnimation() { AkSoundEngine.PostEvent(Events.Play_boss_falseson_skill1_swing, ((EntityState)this).gameObject); int num = step; int num2 = num; if (num2 == 2) { ((EntityState)this).PlayAnimation("LeftArm, Override", "SwingMelee2", "Melee.playbackRate", ((BasicMeleeAttack)this).duration, 0f); } else { ((EntityState)this).PlayAnimation("LeftArm, Override", "SwingMelee1", "Melee.playbackRate", ((BasicMeleeAttack)this).duration, 0f); } } public override void FixedUpdate() { base.FixedUpdate(); ((BaseState)this).StartAimMode(0.2f, false); } public void SetStep(int i) { step = i + 1; } public override void OnSerialize(NetworkWriter writer) { ((EntityState)this).OnSerialize(writer); writer.Write(step); } public override void OnDeserialize(NetworkReader reader) { ((EntityState)this).OnDeserialize(reader); step = reader.ReadInt32(); } public override InterruptPriority GetMinimumInterruptPriority() { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0005: Unknown result type (might be due to invalid IL or missing references) return (InterruptPriority)2; } } public class PermeateCorrupt : CoolerBasicMeleeAttack, IStepSetter { private int step; public override float BaseDuration => 0.3f; public override float DamageCoefficient => PermeateSD.DAMAGE_COEFF_CORRUPT; public override string HitboxName => "Melee"; public override GameObject HitEffectPrefab => GameObject.VoidSurvivorBeamImpactCorrupt; public override float ProcCoefficient => 1f; public override float HitPauseDuration => 0.05f; public override GameObject SwingEffectPrefab => null; public override string MuzzleString => "MuzzleMelee"; public override string MechanimHitboxParameter => "Melee.hitBoxActive"; public override void OnEnter() { //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) base.OnEnter(); int num = step; if (1 == 0) { } GameObject swingEffectPrefab = ((num != 2) ? CorruptedPermeateSD.Slash1 : CorruptedPermeateSD.Slash2); if (1 == 0) { } ((BasicMeleeAttack)this).swingEffectPrefab = swingEffectPrefab; ((BasicMeleeAttack)this).forceVector = Vector3.zero; ((BasicMeleeAttack)this).shorthopVelocityFromHit = 3f; ((EntityState)this).characterMotor.walkSpeedPenaltyCoefficient = PermeateSD.CORRUPT_SPEED_BONUS; } public override void OnExit() { ((BasicMeleeAttack)this).OnExit(); ((EntityState)this).characterMotor.walkSpeedPenaltyCoefficient = 1f; } public override void PlayAnimation() { AkSoundEngine.PostEvent(Events.Play_boss_falseson_skill1_swing, ((EntityState)this).gameObject); int num = step; int num2 = num; if (num2 == 2) { ((EntityState)this).PlayAnimation("LeftArm, Override", "SwingMelee2", "Melee.playbackRate", ((BasicMeleeAttack)this).duration, 0f); } else { ((EntityState)this).PlayAnimation("LeftArm, Override", "SwingMelee1", "Melee.playbackRate", ((BasicMeleeAttack)this).duration, 0f); } } public override void AuthorityModifyOverlapAttack(OverlapAttack overlapAttack) { //IL_000a: Unknown result type (might be due to invalid IL or missing references) ((BasicMeleeAttack)this).AuthorityModifyOverlapAttack(overlapAttack); DamageAPI.AddModdedDamageType(overlapAttack, CorruptedPermeateSD.CorruptNullifyType); } public override void FixedUpdate() { base.FixedUpdate(); ((BaseState)this).StartAimMode(0.2f, false); } public void SetStep(int i) { step = i + 1; } public override void OnSerialize(NetworkWriter writer) { ((EntityState)this).OnSerialize(writer); writer.Write(step); } public override void OnDeserialize(NetworkReader reader) { ((EntityState)this).OnDeserialize(reader); step = reader.ReadInt32(); } public override InterruptPriority GetMinimumInterruptPriority() { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0005: Unknown result type (might be due to invalid IL or missing references) return (InterruptPriority)2; } } public class Suppress : TweakBase { public static float Healing; public static int MaxCharges; public static float CorruptionLoss; public override string Name => "Special : Suppress"; public override string SkillToken => "special"; public override string DescTe
