Decompiled source of PassiveAgression v1.4.2

plugins/PassiveAgression/PassiveAgression.dll

Decompiled 4 days ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AncientScepter;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using ChefMod;
using Deputy;
using DiggerPlugin;
using EmotesAPI;
using EntityStates;
using EntityStates.Bandit2;
using EntityStates.Bandit2.Weapon;
using EntityStates.Captain.Weapon;
using EntityStates.CaptainSupplyDrop;
using EntityStates.Croco;
using EntityStates.Digger;
using EntityStates.Enforcer;
using EntityStates.Loader;
using EntityStates.Mage;
using EntityStates.Mage.Weapon;
using EntityStates.Merc;
using EntityStates.VoidInfestor;
using EntityStates.VoidSurvivor;
using EntityStates.VoidSurvivor.CorruptMode;
using EntityStates.VoidSurvivor.Weapon;
using ExtraSkillSlots;
using GanondorfMod.Modules;
using GanondorfMod.Modules.Survivors;
using HG;
using HG.GeneralSerializer;
using HenryMod.Modules;
using HenryMod.Modules.Survivors;
using HenryMod.SkillStates.BaseStates;
using HenryMod.SkillStates.Henry.Frenzy;
using HouseMod.Modules;
using HouseMod.Modules.Components;
using HouseMod.Modules.Survivors;
using HouseMod.SkillStates.House;
using HouseMod.SkillStates.House.TheGame;
using IL.EntityStates;
using IL.EntityStates.CaptainSupplyDrop;
using IL.EntityStates.Loader;
using IL.EntityStates.Mage;
using IL.EntityStates.Mage.Weapon;
using IL.EntityStates.VoidInfestor;
using IL.RoR2;
using IL.RoR2.Projectile;
using KinematicCharacterController;
using Microsoft.CodeAnalysis;
using Modules;
using Modules.Characters;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using On.EntityStates;
using On.EntityStates.CaptainSupplyDrop;
using On.EntityStates.VoidSurvivor.CorruptMode;
using On.RoR2;
using On.RoR2.Projectile;
using PaladinMod;
using PaladinMod.Misc;
using PaladinMod.Modules;
using PaladinMod.States;
using PassiveAgression.Bandit;
using PassiveAgression.Captain;
using PassiveAgression.Commando;
using PassiveAgression.Croc;
using PassiveAgression.Engineer;
using PassiveAgression.Huntress;
using PassiveAgression.Loader;
using PassiveAgression.Mage;
using PassiveAgression.Merc;
using PassiveAgression.ModCompat;
using PassiveAgression.Railgunner;
using PassiveAgression.VoidSurvivor;
using Pathfinder;
using R2API;
using R2API.Networking;
using R2API.Networking.Interfaces;
using RedGuyMod.Content;
using RedGuyMod.Content.Components;
using RedGuyMod.Content.Survivors;
using RedGuyMod.Modules;
using RedGuyMod.SkillStates.Ravager;
using RiskOfRuinaMod;
using RiskOfRuinaMod.Modules;
using RiskOfRuinaMod.Modules.Components;
using RiskOfRuinaMod.Modules.Survivors;
using RoR2;
using RoR2.CharacterAI;
using RoR2.Items;
using RoR2.Navigation;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2.Skills;
using RoR2.UI;
using RoR2BepInExPack.Utilities;
using RobDriver.Modules.Components;
using RobDriver.Modules.Weapons;
using RobDriver.SkillStates.Driver;
using Skillstates.Deputy;
using Skillstates.Pathfinder;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.UI;

[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("PassiveAgression")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+5c0c2e4545653bc56933271fe3edc1f7d30040d6")]
[assembly: AssemblyProduct("PassiveAgression")]
[assembly: AssemblyTitle("PassiveAgression")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace PassiveAgression
{
	public static class Coin
	{
		public class CoinState : GenericProjectileBaseState
		{
			internal static GameObject coinPref;

			public override void OnEnter()
			{
				base.projectilePrefab = coinPref;
				base.baseDuration = 0.1f;
				((GenericProjectileBaseState)this).OnEnter();
			}

			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 CoinProjectileComponent : MonoBehaviour, IProjectileImpactBehavior
		{
			public static GameObject coinTracerPrefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Toolbot/TracerToolbotRebar.prefab").WaitForCompletion();

			public static List<CoinProjectileComponent> instances = new List<CoinProjectileComponent>();

			private bool redState = false;

			private bool glintState = false;

			private BulletAttack redAttack;

			public void Awake()
			{
				Rigidbody component = ((Component)this).GetComponent<Rigidbody>();
				component.isKinematic = false;
			}

			public void Start()
			{
				//IL_003a: 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_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				GameObject owner = ((Component)this).GetComponent<ProjectileController>().owner;
				CharacterBody val = ((owner != null) ? owner.GetComponent<CharacterBody>() : null);
				if (NetworkServer.active)
				{
					Rigidbody component = ((Component)this).GetComponent<Rigidbody>();
					component.isKinematic = false;
					component.AddForce(val.inputBank.aimDirection * 25f + Vector3.up * 20f + val.characterMotor.velocity, (ForceMode)2);
				}
				instances.Add(this);
			}

			public void Update()
			{
				if (redState)
				{
				}
				if (!glintState)
				{
				}
			}

			public void OnDestroy()
			{
				instances.Remove(this);
			}

			public void OnProjectileImpact(ProjectileImpactInfo info)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)info.collider) && !Object.op_Implicit((Object)(object)((Component)info.collider).GetComponent<HurtBox>()))
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
				}
			}

			public void WasHit(bool playerHit, BulletAttack attack)
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: 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_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: 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_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: 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_00bb: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: 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)
				RaycastHit val2 = default(RaycastHit);
				for (int num = instances.Count - 1; num >= 0; num--)
				{
					CoinProjectileComponent coinProjectileComponent = instances[num];
					if (!((Object)(object)coinProjectileComponent == (Object)(object)this))
					{
						Vector3 val = ((Component)coinProjectileComponent).transform.position - ((Component)this).transform.position;
						if (!Physics.Raycast(((Component)this).transform.position, val, ref val2, ((Vector3)(ref val)).magnitude, LayerMask.op_Implicit(((LayerIndex)(ref LayerIndex.world)).mask), (QueryTriggerInteraction)0))
						{
							new BulletAttack
							{
								origin = ((Component)this).transform.position,
								aimVector = val,
								owner = attack.owner,
								weapon = ((Component)this).gameObject,
								procCoefficient = attack.procCoefficient,
								procChainMask = attack.procChainMask,
								hitCallback = attack.hitCallback,
								modifyOutgoingDamageCallback = attack.modifyOutgoingDamageCallback,
								tracerEffectPrefab = (Object.op_Implicit((Object)(object)attack.tracerEffectPrefab) ? attack.tracerEffectPrefab : coinTracerPrefab),
								minSpread = 0f,
								maxSpread = 0f,
								hitEffectPrefab = attack.hitEffectPrefab
							}.Fire();
							Object.Destroy((Object)(object)((Component)this).gameObject);
							return;
						}
					}
				}
				if (redAttack == attack || playerHit)
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
					return;
				}
				redState = true;
				redAttack = attack;
			}
		}

		public static AssignableSkillDef def;

		public static CoinProjectileComponent[] activeCoins;

		public static bool isHooked;

		static Coin()
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: 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_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Expected O, but got Unknown
			LanguageAPI.Add("PASSIVEAGRESSION_MARKSMANCOIN", "Coin Toss");
			LanguageAPI.Add("PASSIVEAGRESSION_MARKSMANCOIN_DESC", "Toss a coin.");
			def = ScriptableObject.CreateInstance<AssignableSkillDef>();
			((SkillDef)def).skillNameToken = "PASSIVEAGRESSION_MARKSMANCOIN";
			((Object)def).name = ((SkillDef)def).skillNameToken;
			((SkillDef)def).skillDescriptionToken = "PASSIVEAGRESSION_MARKSMANCOIN_DESC";
			((SkillDef)def).baseRechargeInterval = 6f;
			((SkillDef)def).canceledFromSprinting = false;
			((SkillDef)def).cancelSprintingOnActivation = false;
			((SkillDef)def).activationStateMachineName = "Weapon";
			((SkillDef)def).mustKeyPress = true;
			((SkillDef)def).activationState = new SerializableEntityStateType(typeof(CoinState));
			def.onAssign = delegate
			{
				if (!isHooked)
				{
					isHooked = true;
					Run.onRunDestroyGlobal += unsub;
				}
				return (BaseSkillInstanceData)null;
			};
			AssignableSkillDef assignableSkillDef = def;
			assignableSkillDef.onUnassign = (Action<GenericSkill>)Delegate.Combine(assignableSkillDef.onUnassign, (Action<GenericSkill>)delegate
			{
			});
			ContentAddition.AddSkillDef((SkillDef)(object)def);
			bool flag = default(bool);
			ContentAddition.AddEntityState(typeof(CoinState), ref flag);
			GameObject val = PrefabAPI.InstantiateClone(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Commando/CommandoGrenadeProjectile.prefab").WaitForCompletion(), "CoinProjectile");
			val.GetComponent<ProjectileController>().ghostPrefab = PrefabAPI.InstantiateClone(val.GetComponent<ProjectileController>().ghostPrefab, "CoinProjectileGhost", false);
			Object.Destroy((Object)(object)val.GetComponent<ProjectileImpactExplosion>());
			Object.Destroy((Object)(object)val.GetComponent<ProjectileSimple>());
			HurtBox val2 = val.AddComponent<HurtBox>();
			HurtBoxGroup val3 = ((Component)val2).gameObject.AddComponent<HurtBoxGroup>();
			val3.mainHurtBox = val2;
			val3.hurtBoxes = (HurtBox[])(object)new HurtBox[1] { val2 };
			val3.bullseyeCount = 1;
			val2.hurtBoxGroup = val3;
			val2.isBullseye = true;
			val2.isSniperTarget = true;
			val2.indexInGroup = 0;
			val2.damageModifier = (DamageModifier)0;
			val.layer = LayerIndex.projectile.intVal;
			val.AddComponent<CoinProjectileComponent>();
			val.GetComponent<ProjectileController>().startSound = "";
			val.GetComponent<Rigidbody>().isKinematic = false;
			ContentAddition.AddProjectile(val);
			CoinState.coinPref = val;
			BulletAttack.DefaultHitCallbackImplementation += (hook_DefaultHitCallbackImplementation)delegate(orig_DefaultHitCallbackImplementation orig, BulletAttack bulletAttack, ref BulletHit hitInfo)
			{
				if (Object.op_Implicit((Object)(object)hitInfo.entityObject) && Object.op_Implicit((Object)(object)hitInfo.entityObject.GetComponent<CoinProjectileComponent>()))
				{
					hitInfo.entityObject.GetComponent<CoinProjectileComponent>().WasHit(bulletAttack.owner.GetComponent<CharacterBody>().isPlayerControlled, bulletAttack);
				}
				return orig.Invoke(bulletAttack, ref hitInfo);
			};
			static void unsub(Run run)
			{
				Run.onRunDestroyGlobal -= unsub;
				isHooked = false;
			}
		}

		public static void SetMarksman(GameObject bodyPrefab, SkillFamily family, UnlockableDef unlock = null)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			if (PassiveAgressionPlugin.unfinishedContent.Value)
			{
				ref Variant[] variants = ref family.variants;
				Variant val = new Variant
				{
					skillDef = (SkillDef)(object)def
				};
				((Variant)(ref val)).viewableNode = new Node(((SkillDef)def).skillNameToken, false, (Node)null);
				val.unlockableDef = unlock;
				ArrayUtils.ArrayAppend<Variant>(ref variants, ref val);
			}
		}

		public static void SetMarksman(GameObject bodyPrefab, SkillSlot slot, UnlockableDef unlock = null)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			SetMarksman(bodyPrefab, bodyPrefab.GetComponent<SkillLocator>().GetSkill(slot).skillFamily, unlock);
		}
	}
	public class DamagePickup : MonoBehaviour
	{
		[Tooltip("The base object to destroy when this pickup is consumed.")]
		public GameObject baseObject;

		[Tooltip("The team mask object which determines who can pick up this pack.")]
		public TeamMask teamFilter;

		public GameObject pickupEffect;

		public GameObject owner;

		public float damage;

		private bool alive = true;

		private void OnTriggerStay(Collider other)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			if (!NetworkServer.active || !alive || !((TeamMask)(ref teamFilter)).HasTeam(TeamComponent.GetObjectTeam(((Component)other).gameObject)))
			{
				return;
			}
			CharacterBody component = ((Component)other).GetComponent<CharacterBody>();
			if (Object.op_Implicit((Object)(object)component))
			{
				HealthComponent healthComponent = component.healthComponent;
				if (Object.op_Implicit((Object)(object)healthComponent))
				{
					component.healthComponent.TakeDamage(new DamageInfo
					{
						damage = damage,
						attacker = owner,
						inflictor = ((Component)this).gameObject,
						force = Vector3.zero,
						procCoefficient = 1f,
						position = ((Component)this).transform.position
					});
					EffectManager.SpawnEffect(pickupEffect, new EffectData
					{
						origin = ((Component)this).transform.position
					}, true);
				}
				Object.Destroy((Object)(object)baseObject);
			}
		}
	}
	[RequireComponent(typeof(CharacterMaster))]
	[RequireComponent(typeof(MinionOwnership))]
	public class DoppelInputBank : MonoBehaviour
	{
		internal class EmoteQueueItem
		{
			internal uint command;

			internal ushort delay;

			internal string emoteName;
		}

		internal static bool ExtraSSInputs = Chainloader.PluginInfos.ContainsKey("com.KingEnderBrine.ExtraSkillSlots");

		internal static bool EmoteAPIInputs = Chainloader.PluginInfos.ContainsKey("com.weliveinasociety.CustomEmotesAPI");

		internal Queue<bool[]> ExtraInputBuffer = (ExtraSSInputs ? new Queue<bool[]>() : null);

		internal List<EmoteQueueItem> EmoteInputBuffer = (EmoteAPIInputs ? new List<EmoteQueueItem>() : null);

		public Queue<BodyInputs> inputBuffer = new Queue<BodyInputs>(5);

		public InputBankTest bodyInputs;

		public InputBankTest ownerInputs;

		public ushort updateDelay = 0;

		public CharacterMaster master { get; private set; }

		public NetworkIdentity networkIdentity { get; protected set; }

		public void Awake()
		{
			master = ((Component)this).GetComponent<CharacterMaster>();
		}

		public void Start()
		{
			bodyInputs = master.GetBody().inputBank;
			ownerInputs = master.minionOwnership.ownerMaster.GetBody().inputBank;
			if (EmoteAPIInputs)
			{
				HandleEmoteInputs(setup: true);
			}
		}

		public void FixedUpdate()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: 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_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: 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_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)ownerInputs))
			{
				inputBuffer.Enqueue(new BodyInputs
				{
					desiredAimDirection = ownerInputs.aimDirection,
					moveVector = ownerInputs.moveVector,
					pressActivateEquipment = ownerInputs.activateEquipment.down,
					pressJump = ownerInputs.jump.down,
					pressSkill1 = ownerInputs.skill1.down,
					pressSkill2 = ownerInputs.skill2.down,
					pressSkill3 = ownerInputs.skill3.down,
					pressSkill4 = ownerInputs.skill4.down,
					pressSprint = ownerInputs.sprint.down
				});
			}
			if (ExtraSSInputs)
			{
				HandleExtraSlots(record: true);
			}
			if (master.hasEffectiveAuthority && Object.op_Implicit((Object)(object)bodyInputs) && inputBuffer.Count >= updateDelay)
			{
				BodyInputs val = inputBuffer.Dequeue();
				((ButtonState)(ref bodyInputs.skill1)).PushState(val.pressSkill1);
				((ButtonState)(ref bodyInputs.skill2)).PushState(val.pressSkill2);
				((ButtonState)(ref bodyInputs.skill3)).PushState(val.pressSkill3);
				((ButtonState)(ref bodyInputs.skill4)).PushState(val.pressSkill4);
				((ButtonState)(ref bodyInputs.jump)).PushState(val.pressJump);
				((ButtonState)(ref bodyInputs.sprint)).PushState(val.pressSprint);
				((ButtonState)(ref bodyInputs.activateEquipment)).PushState(val.pressActivateEquipment);
				bodyInputs.moveVector = val.moveVector;
				bodyInputs.aimDirection = val.desiredAimDirection;
				if (ExtraSSInputs)
				{
					HandleExtraSlots(record: false);
				}
				if (EmoteAPIInputs)
				{
					HandleEmoteInputs();
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal void HandleExtraSlots(bool record)
		{
			if (record)
			{
				ExtraInputBankTest component = ((Component)master.minionOwnership.ownerMaster).GetComponent<ExtraInputBankTest>();
				if (Object.op_Implicit((Object)(object)component))
				{
					ExtraInputBuffer.Enqueue(new bool[4]
					{
						component.extraSkill1.down,
						component.extraSkill2.down,
						component.extraSkill3.down,
						component.extraSkill4.down
					});
				}
			}
			else
			{
				ExtraInputBankTest component2 = ((Component)master).GetComponent<ExtraInputBankTest>();
				if (Object.op_Implicit((Object)(object)component2) && master.hasEffectiveAuthority && ExtraInputBuffer.Count >= updateDelay)
				{
					bool[] array = ExtraInputBuffer.Dequeue();
					((ButtonState)(ref component2.extraSkill1)).PushState(array[0]);
					((ButtonState)(ref component2.extraSkill2)).PushState(array[1]);
					((ButtonState)(ref component2.extraSkill3)).PushState(array[2]);
					((ButtonState)(ref component2.extraSkill4)).PushState(array[3]);
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal void HandleEmoteInputs(bool setup = false)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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
			CharacterMaster obj = master;
			object obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				CharacterBody body = obj.GetBody();
				if (body == null)
				{
					obj2 = null;
				}
				else
				{
					ModelLocator modelLocator = body.modelLocator;
					obj2 = ((modelLocator != null) ? ((Component)modelLocator.modelTransform).GetComponentInChildren<BoneMapper>() : null);
				}
			}
			BoneMapper selfB = (BoneMapper)obj2;
			if (!Object.op_Implicit((Object)(object)selfB))
			{
				CustomEmotesAPI.animChanged -= new AnimationChanged(animChanged);
				return;
			}
			if (setup)
			{
				CustomEmotesAPI.animChanged += new AnimationChanged(animChanged);
				return;
			}
			foreach (EmoteQueueItem item in EmoteInputBuffer.ToList())
			{
				item.delay--;
				if (item.delay > 0)
				{
					continue;
				}
				switch (item.command)
				{
				case 0u:
					CustomEmotesAPI.PlayAnimation(item.emoteName, selfB, -2);
					break;
				case 2u:
				{
					GameObject currentEmoteSpot = selfB.currentEmoteSpot;
					if (Object.op_Implicit((Object)(object)((currentEmoteSpot == null) ? null : currentEmoteSpot.GetComponent<EmoteLocation>()?.emoter)))
					{
						EmoteLocation[] componentsInChildren = ((Component)selfB.currentEmoteSpot.transform.parent).GetComponentsInChildren<EmoteLocation>();
						foreach (EmoteLocation val in componentsInChildren)
						{
							if (!Object.op_Implicit((Object)(object)val.emoter))
							{
								selfB.currentEmoteSpot = ((Component)val).gameObject;
								break;
							}
						}
					}
					selfB.JoinEmoteSpot();
					break;
				}
				}
				EmoteInputBuffer.Remove(item);
			}
			void animChanged(string a, BoneMapper b)
			{
				if ((Object)(object)b.mapperBody.inputBank == (Object)(object)ownerInputs)
				{
					if (a != "none" && b.currentClip.joinSpots != null && b.currentClip.joinSpots.Length != 0)
					{
						CustomEmotesAPI.ReserveJoinSpot(((Component)b.emoteLocations.First()).gameObject, selfB);
						EmoteInputBuffer.Add(new EmoteQueueItem
						{
							command = 2u,
							delay = Math.Max(updateDelay, (ushort)1),
							emoteName = a
						});
					}
					else
					{
						EmoteInputBuffer.Add(new EmoteQueueItem
						{
							command = 0u,
							delay = Math.Max(updateDelay, (ushort)1),
							emoteName = a
						});
					}
				}
			}
		}
	}
	public class CustomPassiveSlot
	{
		internal string prefabString = null;

		internal GameObject bodyPrefab = null;

		internal GenericSkill skill = null;

		internal static int orderCounter;

		public static SkillDef NoneDef;

		public static SkillDef NoneDefMerc;

		internal SkillFamily family
		{
			get
			{
				GenericSkill obj = skill;
				return (obj != null) ? obj.skillFamily : null;
			}
		}

		static CustomPassiveSlot()
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			orderCounter = 0;
			LanguageAPI.Add("PASSIVEAGRESSION_NONE", "None");
			LanguageAPI.Add("PASSIVEAGRESSION_NONE_DESC", "Not all who wander are lost.");
			NoneDef = ScriptableObject.CreateInstance<SkillDef>();
			NoneDef.skillNameToken = "PASSIVEAGRESSION_NONE";
			((Object)NoneDef).name = NoneDef.skillNameToken;
			NoneDef.skillDescriptionToken = "PASSIVEAGRESSION_NONE_DESC";
			NoneDef.icon = Util.SpriteFromFile("nonedef.png");
			NoneDef.baseRechargeInterval = 0f;
			NoneDef.activationState = new SerializableEntityStateType(typeof(Idle));
			NoneDef.activationStateMachineName = "Body";
			ContentAddition.AddSkillDef(NoneDef);
		}

		public CustomPassiveSlot(string path)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			bodyPrefab = Addressables.LoadAssetAsync<GameObject>((object)path).WaitForCompletion();
			prefabString = path;
			Init(!bodyPrefab.GetComponent<SkillLocator>().passiveSkill.enabled);
		}

		public CustomPassiveSlot(string path, bool useNone)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			bodyPrefab = Addressables.LoadAssetAsync<GameObject>((object)path).WaitForCompletion();
			prefabString = path;
			Init(useNone);
		}

		public CustomPassiveSlot(GameObject prefab)
		{
			bodyPrefab = prefab;
			Init(!bodyPrefab.GetComponent<SkillLocator>().passiveSkill.enabled);
		}

		public CustomPassiveSlot(GameObject prefab, bool useNone)
		{
			bodyPrefab = prefab;
			Init(useNone);
		}

		public void Init(bool SetupNone = true)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Expected O, but got Unknown
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Expected O, but got Unknown
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)bodyPrefab) && prefabString != null)
			{
				bodyPrefab = Addressables.LoadAssetAsync<GameObject>((object)prefabString).WaitForCompletion();
			}
			if (!Object.op_Implicit((Object)(object)bodyPrefab))
			{
				return;
			}
			GenericSkill[] components = bodyPrefab.GetComponents<GenericSkill>();
			foreach (GenericSkill val in components)
			{
				if (((Object)val.skillFamily).name.ToLower().Contains("passive"))
				{
					skill = val;
					if (string.IsNullOrEmpty(skill.loadoutTitleToken))
					{
						skill.loadoutTitleToken = "Passive";
					}
					if (SkillsAPI.GetOrderPriority(skill) >= 0)
					{
						SkillsAPI.SetOrderPriority(skill, -1);
					}
					return;
				}
			}
			skill = bodyPrefab.AddComponent<GenericSkill>();
			SkillLocator component = bodyPrefab.GetComponent<SkillLocator>();
			skill._skillFamily = ScriptableObject.CreateInstance<SkillFamily>();
			((Object)skill.skillFamily).name = ((Object)bodyPrefab).name + "Passive";
			skill.loadoutTitleToken = "Passive";
			SkillsAPI.SetOrderPriority(skill, -1);
			skill.skillFamily.variants = (Variant[])(object)new Variant[1];
			skill.skillName = ((Object)bodyPrefab).name + "Passive";
			Variant val2;
			if (SetupNone)
			{
				Variant[] variants = skill.skillFamily.variants;
				val2 = new Variant
				{
					skillDef = NoneDef
				};
				((Variant)(ref val2)).viewableNode = new Node(NoneDef.skillNameToken, false, (Node)null);
				variants[0] = val2;
			}
			else if (component.passiveSkill.enabled)
			{
				component.passiveSkill.enabled = false;
				SkillDef val3 = ScriptableObject.CreateInstance<SkillDef>();
				val3.skillNameToken = component.passiveSkill.skillNameToken;
				((Object)val3).name = val3.skillNameToken;
				val3.skillDescriptionToken = component.passiveSkill.skillDescriptionToken;
				val3.icon = component.passiveSkill.icon;
				val3.keywordTokens = ((component.passiveSkill.keywordToken.Length <= 0) ? null : new string[1] { component.passiveSkill.keywordToken });
				val3.baseRechargeInterval = 0f;
				val3.activationStateMachineName = "Body";
				val3.activationState = new SerializableEntityStateType(typeof(GenericCharacterMain));
				val3.canceledFromSprinting = false;
				val3.cancelSprintingOnActivation = false;
				ContentAddition.AddSkillDef(val3);
				Variant[] variants2 = skill.skillFamily.variants;
				val2 = new Variant
				{
					skillDef = val3
				};
				((Variant)(ref val2)).viewableNode = new Node(val3.skillNameToken, false, (Node)null);
				variants2[0] = val2;
			}
			ContentAddition.AddSkillFamily(skill.skillFamily);
		}
	}
	public class AssignableSkillDef : SkillDef
	{
		public Func<GenericSkill, BaseSkillInstanceData> onAssign;

		public Action<GenericSkill> onUnassign;

		public override BaseSkillInstanceData OnAssigned(GenericSkill skillSlot)
		{
			return onAssign?.Invoke(skillSlot);
		}

		public override void OnUnassigned(GenericSkill skillSlot)
		{
			((SkillDef)this).OnUnassigned(skillSlot);
			onUnassign?.Invoke(skillSlot);
		}

		public bool IsAssigned(CharacterBody body)
		{
			return Array.Exists(body.skillLocator.allSkills, IsAssigned);
		}

		public bool IsAssigned(GenericSkill skill)
		{
			return (Object)(object)skill.skillDef == (Object)(object)this;
		}

		public bool IsAssigned(CharacterBody body, SkillSlot skillSlot)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return (Object)(object)body.skillLocator.GetSkill(skillSlot).skillDef == (Object)(object)this;
		}

		public GenericSkill GetSkill(CharacterBody body)
		{
			if (Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)body.skillLocator))
			{
				for (int i = 0; i < body.skillLocator.allSkills.Length; i++)
				{
					if (IsAssigned(body.skillLocator.allSkills[i]))
					{
						return body.skillLocator.allSkills[i];
					}
				}
			}
			return null;
		}
	}
	public class SingleUseSkillDef : AssignableSkillDef
	{
		public SkillOverridePriority overridePriority = (SkillOverridePriority)4;

		public override void OnExecute(GenericSkill skillSlot)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			((SkillDef)this).OnExecute(skillSlot);
			if (skillSlot.stock <= 0)
			{
				skillSlot.UnsetSkillOverride((object)((Component)skillSlot).gameObject, (SkillDef)(object)this, overridePriority);
			}
		}
	}
	public class SpeenComponent : MonoBehaviour
	{
		public static FixedConditionalWeakTable<Transform, List<SpeenComponent>> instances = new FixedConditionalWeakTable<Transform, List<SpeenComponent>>();

		public Transform radiusOrigin;

		public float turnAnimTimer;

		public float radius = -1f;

		public CharacterBody targetBody;

		private void Start()
		{
			if (Object.op_Implicit((Object)(object)radiusOrigin) && !Object.op_Implicit((Object)(object)targetBody) && radius == -1f)
			{
				targetBody = ((Component)radiusOrigin).gameObject.GetComponent<CharacterBody>();
			}
			if (Object.op_Implicit((Object)(object)targetBody))
			{
				radius = targetBody.radius + 0.25f;
				radiusOrigin = targetBody.coreTransform;
			}
			instances.GetOrCreateValue(radiusOrigin).Add(this);
		}

		private void Update()
		{
			//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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)radiusOrigin))
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			Vector3 position = radiusOrigin.position;
			turnAnimTimer += Time.deltaTime;
			List<SpeenComponent> orCreateValue = instances.GetOrCreateValue(radiusOrigin);
			float num = MathF.PI * 2f / (float)orCreateValue.Count;
			float num2 = num * (float)orCreateValue.IndexOf(this) + turnAnimTimer;
			((Component)this).transform.position = new Vector3((float)((double)radius * Math.Cos(num2) + (double)position.x), position.y, (float)((double)radius * Math.Sin(num2) + (double)position.z));
		}

		private void OnDestroy()
		{
			if (Object.op_Implicit((Object)(object)radiusOrigin))
			{
				instances.GetOrCreateValue(radiusOrigin).Remove(this);
			}
		}
	}
	public static class Util
	{
		public static Xoroshiro128Plus miscRNG;

		public static EntityStateIndex immobState;

		public static EntityStateIndex stunState;

		public static EntityStateIndex shockState;

		public static EntityStateIndex idleState;

		public static BodyIndex mitchellIndex1;

		public static BodyIndex mitchellIndex2;

		static Util()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_000d: 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)
			miscRNG = new Xoroshiro128Plus(0uL);
			idleState = (EntityStateIndex)(-1);
			mitchellIndex2 = (BodyIndex)(-1);
			Run.onRunStartGlobal += delegate(Run run)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Expected O, but got Unknown
				if (NetworkServer.active)
				{
					miscRNG = new Xoroshiro128Plus(run.runRNG);
				}
			};
		}

		public static void OnStateWorkFinished(EntityStateMachine machine, ModifyNextStateDelegate del, List<Type> additionalStops = null)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_004a: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)machine))
			{
				if ((int)idleState == -1)
				{
					immobState = EntityStateCatalog.GetStateIndex(typeof(ImmobilizeState));
					stunState = EntityStateCatalog.GetStateIndex(typeof(StunState));
					shockState = EntityStateCatalog.GetStateIndex(typeof(ShockState));
					idleState = EntityStateCatalog.GetStateIndex(typeof(Idle));
				}
				EntityStateMachine obj = machine;
				obj.nextStateModifier = (ModifyNextStateDelegate)Delegate.Combine((Delegate?)(object)obj.nextStateModifier, (Delegate?)new ModifyNextStateDelegate(logic));
			}
			void logic(EntityStateMachine mach, ref EntityState state)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Expected O, but got Unknown
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Expected O, but got Unknown
				//IL_0077: 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_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: 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_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				Type type = ((object)state).GetType();
				EntityStateIndex stateIndex = EntityStateCatalog.GetStateIndex(type);
				if (!(((SerializableEntityStateType)(ref machine.mainStateType)).stateType == type))
				{
					EntityState obj2 = state;
					bool? obj3;
					if (obj2 == null)
					{
						obj3 = null;
					}
					else
					{
						HealthComponent healthComponent = obj2.healthComponent;
						obj3 = ((healthComponent != null) ? new bool?(healthComponent.isInFrozenState) : ((bool?)null));
					}
					bool? flag = obj3;
					if (flag != true && (additionalStops == null || !additionalStops.Contains(type)) && stateIndex != immobState && stateIndex != stunState && stateIndex != shockState && stateIndex != idleState)
					{
						return;
					}
				}
				del.Invoke(mach, ref state);
				mach.nextStateModifier = (ModifyNextStateDelegate)Delegate.Remove((Delegate?)(object)mach.nextStateModifier, (Delegate?)new ModifyNextStateDelegate(logic));
			}
		}

		public static bool BodyIsMitchell(CharacterBody body)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)body))
			{
				return false;
			}
			if ((int)mitchellIndex2 == -1)
			{
				mitchellIndex1 = BodyCatalog.FindBodyIndex("BrotherBody");
				mitchellIndex2 = BodyCatalog.FindBodyIndex("BrotherHurtBody");
			}
			return body.bodyIndex == mitchellIndex1 || body.bodyIndex == mitchellIndex2;
		}

		public static bool GetRandomDebuffOrDot(CharacterBody body, out BuffIndex debuff, out DotStack dot)
		{
			//IL_00f9: 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_0171: Expected I4, but got Unknown
			debuff = (BuffIndex)(-1);
			dot = null;
			if (!NetworkServer.active || !Object.op_Implicit((Object)(object)body))
			{
				return false;
			}
			List<BuffIndex> list = new List<BuffIndex>();
			List<DotStack> list2 = new List<DotStack>();
			BuffIndex[] activeBuffsList = body.activeBuffsList;
			if (((activeBuffsList != null && activeBuffsList.Length != 0) ? 1 : 0) > (false ? 1 : 0))
			{
				list = body.activeBuffsList.Where((BuffIndex buffIndex) => BuffCatalog.GetBuffDef(buffIndex).isDebuff).ToList();
			}
			if (DotController.dotControllerLocator.TryGetValue(((Object)((Component)body).gameObject).GetInstanceID(), out var value) && value.dotStackList != null)
			{
				list2 = value.dotStackList;
			}
			foreach (DotStack item in list2)
			{
				if (list.Count > 0 && Object.op_Implicit((Object)(object)item.dotDef.associatedBuff))
				{
					list.Remove(item.dotDef.associatedBuff.buffIndex);
				}
			}
			if (list.Count + list2.Count <= 0)
			{
				return false;
			}
			int num = miscRNG.RangeInt(0, list.Count + list2.Count);
			if (num < list.Count)
			{
				debuff = (BuffIndex)(int)list[num];
			}
			else
			{
				dot = list2[num - list.Count];
			}
			return true;
		}

		public static int CountUniqueItemWithTag(Inventory inventory, ItemTag tag)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return ((IEnumerable<ItemIndex>)(object)ItemCatalog.GetItemsWithTag(tag)).Intersect(inventory.itemAcquisitionOrder).Count();
		}

		public static Sprite SpriteFromFile(string name)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			try
			{
				ImageConversion.LoadImage(val, File.ReadAllBytes(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Assets/" + name)));
			}
			catch (FileNotFoundException ex)
			{
				PassiveAgressionPlugin.Logger.LogError((object)("Failed to read file at " + ex.FileName));
				return null;
			}
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).height, (float)((Texture)val).width), new Vector2(0.5f, 0.5f), 100f);
		}

		public static void recursebull(Transform transform, int acc = 0)
		{
			string text = "";
			for (int i = 0; i < acc; i++)
			{
				text += "-";
			}
			Debug.Log((object)(text + (object)transform));
			Component[] components = ((Component)transform).gameObject.GetComponents<Component>();
			foreach (Component val in components)
			{
				Debug.Log((object)(text + " *" + ((object)val).GetType()));
			}
			for (int k = 0; k < transform.childCount; k++)
			{
				recursebull(transform.GetChild(k), acc + 1);
			}
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("xyz.yekoc.PassiveAgression", "Passive Agression", "1.4.2")]
	public class PassiveAgressionPlugin : BaseUnityPlugin
	{
		internal struct ModList
		{
			internal bool Paladin;

			internal bool Scepter;

			internal bool Chef;

			internal bool Enforcer;

			internal bool Pathfinder;

			internal bool Sniper;

			internal bool Digger;

			internal bool Henry;

			internal bool Deputy;

			internal bool Ganon;

			internal bool House;

			internal bool Ruina;

			internal bool Ravager;

			internal bool Driver;
		}

		public static ConfigEntry<bool> unfinishedContent;

		public static ConfigEntry<bool> devIcons;

		internal static ConfigFile config;

		internal static Sprite unfinishedIcon = Util.SpriteFromFile("StandoffIcon.png");

		internal static ModList modCompat;

		internal static ManualLogSource Logger { get; set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			config = ((BaseUnityPlugin)this).Config;
			unfinishedContent = ((BaseUnityPlugin)this).Config.Bind<bool>("Configuration", "Enable Unfinished Content", false, "Enables Unfinished/Potentially Broken Content");
			devIcons = ((BaseUnityPlugin)this).Config.Bind<bool>("Configuration", "Prefer Dev Icons", false, "Use jank dev-made icons even when better ones are available");
			SetupVanilla();
		}

		private void Start()
		{
			if (modCompat.Paladin = Chainloader.PluginInfos.ContainsKey("com.rob.Paladin"))
			{
				SetupPaladin();
			}
			if (modCompat.Chef = Chainloader.PluginInfos.ContainsKey("com.Gnome.ChefMod"))
			{
				SetupChef();
			}
			if (modCompat.Enforcer = Chainloader.PluginInfos.ContainsKey("com.EnforcerGang.Enforcer"))
			{
				SetupEnforcer();
			}
			if (modCompat.Sniper = Chainloader.PluginInfos.ContainsKey("com.Moffein.SniperClassic"))
			{
				SetupSniper();
			}
			if (modCompat.Pathfinder = Chainloader.PluginInfos.ContainsKey("com.Bog.Pathfinder"))
			{
				SetupPathfinder();
			}
			if (modCompat.Digger = Chainloader.PluginInfos.ContainsKey("com.rob.DiggerUnearthed"))
			{
				SetupDigger();
			}
			if (modCompat.Henry = Chainloader.PluginInfos.ContainsKey("com.rob.HenryMod"))
			{
				SetupHenry();
			}
			if (modCompat.Deputy = Chainloader.PluginInfos.ContainsKey("com.Bog.Deputy"))
			{
				SetupDeputy();
			}
			if (modCompat.Ganon = Chainloader.PluginInfos.ContainsKey("com.Ethanol10.Ganondorf"))
			{
				SetupGanon();
			}
			if (modCompat.House = Chainloader.PluginInfos.ContainsKey("com.JavAngle.HouseMod"))
			{
				SetupHouse();
			}
			if (modCompat.Ruina = Chainloader.PluginInfos.ContainsKey("com.Moonlol.UnofficialRiskOfRuina"))
			{
				SetupRuina();
			}
			if (modCompat.Ravager = Chainloader.PluginInfos.ContainsKey("com.rob.Ravager"))
			{
				SetupRavager();
			}
			if (modCompat.Driver = Chainloader.PluginInfos.ContainsKey("com.rob.Driver"))
			{
			}
			if (modCompat.Scepter = Chainloader.PluginInfos.ContainsKey("com.DestroyedClone.AncientScepter"))
			{
				SetupScepter();
			}
		}

		private void OnDestroy()
		{
		}

		private void SetupVanilla()
		{
			//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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00ac: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_00fc: 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_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Expected O, but got Unknown
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Expected O, but got Unknown
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Expected O, but got Unknown
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Expected O, but got Unknown
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Expected O, but got Unknown
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Expected O, but got Unknown
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Expected O, but got Unknown
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Expected O, but got Unknown
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Expected O, but got Unknown
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fd: Expected O, but got Unknown
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0523: Unknown result type (might be due to invalid IL or missing references)
			//IL_0543: Unknown result type (might be due to invalid IL or missing references)
			//IL_054d: Expected O, but got Unknown
			//IL_054e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Unknown result type (might be due to invalid IL or missing references)
			//IL_0593: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Expected O, but got Unknown
			//IL_059e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f2: Expected O, but got Unknown
			//IL_05f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0618: Unknown result type (might be due to invalid IL or missing references)
			//IL_0638: Unknown result type (might be due to invalid IL or missing references)
			//IL_0642: Expected O, but got Unknown
			//IL_0643: Unknown result type (might be due to invalid IL or missing references)
			//IL_0655: Unknown result type (might be due to invalid IL or missing references)
			//IL_065a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0698: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c2: Expected O, but got Unknown
			//IL_06c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0708: Unknown result type (might be due to invalid IL or missing references)
			//IL_0712: Expected O, but got Unknown
			//IL_0713: Unknown result type (might be due to invalid IL or missing references)
			//IL_0725: Unknown result type (might be due to invalid IL or missing references)
			//IL_072a: Unknown result type (might be due to invalid IL or missing references)
			//IL_076d: Unknown result type (might be due to invalid IL or missing references)
			//IL_078d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0797: Expected O, but got Unknown
			//IL_0798: Unknown result type (might be due to invalid IL or missing references)
			//IL_07aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_07af: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_080d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0817: Expected O, but got Unknown
			//IL_0818: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Commando/CommandoBody.prefab").WaitForCompletion();
			ref Variant[] variants = ref val.GetComponent<SkillLocator>().special.skillFamily.variants;
			Variant variant = new Variant
			{
				skillDef = CommandoStimpack.def
			};
			((Variant)(ref variant)).viewableNode = new Node(CommandoStimpack.def.skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants, variant);
			val = StandoffPassive.slot.bodyPrefab;
			ref Variant[] variants2 = ref StandoffPassive.slot.family.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)StandoffPassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)StandoffPassive.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants2, variant, "BanditShowdown");
			ref Variant[] variants3 = ref val.GetComponent<SkillLocator>().utility.skillFamily.variants;
			variant = new Variant
			{
				skillDef = StarchUtil.def
			};
			((Variant)(ref variant)).viewableNode = new Node(StarchUtil.def.skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants3, variant, "BanditStarch");
			val = RadiusPassive.slot.bodyPrefab;
			ref Variant[] variants4 = ref RadiusPassive.slot.family.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)RadiusPassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)RadiusPassive.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants4, variant, "CaptainSupportive", unfinished: true);
			ref Variant[] variants5 = ref val.GetComponent<SkillLocator>().special.skillFamily.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)IntegratedBeacon.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)IntegratedBeacon.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants5, variant, "CaptainSelfBeacon");
			val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Croco/CrocoBody.prefab").WaitForCompletion();
			ref Variant[] variants6 = ref val.GetComponent<SkillLocator>().special.skillFamily.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)PathogenSpecial.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)PathogenSpecial.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants6, variant);
			val = ScrapPassive.slot.bodyPrefab;
			ref Variant[] variants7 = ref ScrapPassive.slot.family.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)ScrapPassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)ScrapPassive.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants7, variant, "EngiScrap");
			ref Variant[] variants8 = ref val.GetComponent<SkillLocator>().primary.skillFamily.variants;
			variant = new Variant
			{
				skillDef = ResonancePrimary.def
			};
			((Variant)(ref variant)).viewableNode = new Node(ResonancePrimary.def.skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants8, variant, "EngiResonance");
			val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Huntress/HuntressBody.prefab").WaitForCompletion();
			ref Variant[] variants9 = ref val.GetComponent<SkillLocator>().secondary.skillFamily.variants;
			variant = new Variant
			{
				skillDef = LightMine.def
			};
			((Variant)(ref variant)).viewableNode = new Node(LightMine.def.skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants9, variant, "", unfinished: true);
			val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Loader/LoaderBody.prefab").WaitForCompletion();
			ref Variant[] variants10 = ref val.GetComponent<SkillLocator>().secondary.skillFamily.variants;
			variant = new Variant
			{
				skillDef = LoaderZipline.def
			};
			((Variant)(ref variant)).viewableNode = new Node(LoaderZipline.def.skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants10, variant, "", unfinished: true);
			ref Variant[] variants11 = ref val.GetComponent<SkillLocator>().special.skillFamily.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)ElectrifySpecial.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)ElectrifySpecial.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants11, variant, "", unfinished: true);
			val = BleedPassive.slot.bodyPrefab;
			ref Variant[] variants12 = ref val.GetComponent<SkillLocator>().secondary.skillFamily.variants;
			variant = new Variant
			{
				skillDef = FloatingChaos.def
			};
			((Variant)(ref variant)).viewableNode = new Node(FloatingChaos.def.skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants12, variant, "", unfinished: true);
			ref Variant[] variants13 = ref val.GetComponent<SkillLocator>().special.skillFamily.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)IceGolemSpecial.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)IceGolemSpecial.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants13, variant, "MageIceArmor");
			ref Variant[] variants14 = ref BleedPassive.slot.family.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)BleedPassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)BleedPassive.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants14, variant, "MageBloodrite");
			ref Variant[] variants15 = ref IcePassive.slot.family.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)IcePassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)IcePassive.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants15, variant, "MageIcerite");
			ref Variant[] variants16 = ref val.GetComponent<SkillLocator>().primary.skillFamily.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)BloodPrimary.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)BloodPrimary.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants16, variant, "MageBloodbolt");
			ref Variant[] variants17 = ref val.GetComponent<SkillLocator>().special.skillFamily.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)BloodDotSkill.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)BloodDotSkill.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants17, variant, "MageBloodConclude");
			val = ExposePassive.slot.bodyPrefab;
			ref Variant[] variants18 = ref ExposePassive.slot.family.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)ExposePassive.def2
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)ExposePassive.def2).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants18, variant, "MercPlumBlossom");
			ref Variant[] variants19 = ref val.GetComponent<SkillLocator>().secondary.skillFamily.variants;
			variant = new Variant
			{
				skillDef = MassExpose.def
			};
			((Variant)(ref variant)).viewableNode = new Node(MassExpose.def.skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants19, variant, "MercGlare");
			val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSurvivor/VoidSurvivorBody.prefab").WaitForCompletion();
			GenericSkill component = val.GetComponent<GenericSkill>();
			component.loadoutTitleToken = (string.IsNullOrEmpty(component.loadoutTitleToken) ? "Passive" : component.loadoutTitleToken);
			ref Variant[] variants20 = ref component.skillFamily.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)InfestationPassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)InfestationPassive.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants20, variant, "ViendBug");
			ref Variant[] variants21 = ref val.GetComponent<SkillLocator>().utility.skillFamily.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)TearUtil.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)TearUtil.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants21, variant, "ViendTear");
			val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/Railgunner/RailgunnerBody.prefab").WaitForCompletion();
			component = val.GetComponent<GenericSkill>();
			component.loadoutTitleToken = (string.IsNullOrEmpty(component.loadoutTitleToken) ? "Passive" : component.loadoutTitleToken);
			ref Variant[] variants22 = ref ((Component)component).GetComponent<GenericSkill>().skillFamily.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)RailgunnerPassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)RailgunnerPassive.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants22, variant, "RailMissile");
			val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC2/Chef/ChefBody.prefab").WaitForCompletion();
			component = val.GetComponent<GenericSkill>();
			component.loadoutTitleToken = (string.IsNullOrEmpty(component.loadoutTitleToken) ? "Passive" : component.loadoutTitleToken);
			ref Variant[] variants23 = ref component.skillFamily.variants;
			variant = new Variant
			{
				skillDef = (SkillDef)(object)ChefPantryPassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)ChefPantryPassive.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants23, variant, "GBoxChefPantry");
		}

		private void ConfigAndAdd(ref Variant[] family, Variant variant, string name = "", bool unfinished = false)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (!unfinished || unfinishedContent.Value)
			{
				ConfigEntry<bool> val = ((BaseUnityPlugin)this).Config.Bind<bool>((name != string.Empty) ? name : (variant.skillDef.skillNameToken[17] + variant.skillDef.skillNameToken.Substring(18).ToLowerInvariant()), "Enabled", true, "Enables this skill");
				if (val.Value)
				{
					ArrayUtils.ArrayAppend<Variant>(ref family, ref variant);
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupPaladin()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0055: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00cf: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			//IL_0110: 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_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			GameObject bodyPrefab = PaladinDesignPassive.slot.bodyPrefab;
			ref Variant[] variants = ref PaladinDesignPassive.slot.family.variants;
			Variant variant = new Variant
			{
				skillDef = (SkillDef)(object)PaladinDesignPassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)PaladinDesignPassive.def).skillNameToken, false, (Node)null);
			variant.unlockableDef = Unlockables.paladinLunarShardSkillDef;
			ConfigAndAdd(ref variants, variant, "", unfinished: true);
			SkillLocator component = bodyPrefab.GetComponent<SkillLocator>();
			object obj;
			if (component == null)
			{
				obj = null;
			}
			else
			{
				GenericSkill special = component.special;
				obj = ((special != null) ? special.skillFamily : null);
			}
			SkillFamily val = (SkillFamily)obj;
			if (Object.op_Implicit((Object)(object)val))
			{
				ref Variant[] variants2 = ref val.variants;
				variant = new Variant
				{
					skillDef = (SkillDef)(object)PaladinGlassShadow.def
				};
				((Variant)(ref variant)).viewableNode = new Node(((SkillDef)PaladinGlassShadow.def).skillNameToken, false, (Node)null);
				variant.unlockableDef = Unlockables.paladinLunarShardSkillDef;
				ConfigAndAdd(ref variants2, variant, "PaladinClone");
				ref Variant[] variants3 = ref val.variants;
				variant = new Variant
				{
					skillDef = (SkillDef)(object)PaladinBolt.def
				};
				((Variant)(ref variant)).viewableNode = new Node(((SkillDef)PaladinBolt.def).skillNameToken, false, (Node)null);
				ConfigAndAdd(ref variants3, variant, "PaladinSunbolt", unfinished: true);
				ref Variant[] variants4 = ref val.variants;
				variant = new Variant
				{
					skillDef = (SkillDef)(object)PaladinResolve.def
				};
				((Variant)(ref variant)).viewableNode = new Node(((SkillDef)PaladinResolve.def).skillNameToken, false, (Node)null);
				ConfigAndAdd(ref variants4, variant, "PaladinResolve", unfinished: true);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupScepter()
		{
			ItemBase<AncientScepterItem>.instance.RegisterScepterSkill(CommandoStimpackScepter.def, "CommandoBody", CommandoStimpack.def);
			ItemBase<AncientScepterItem>.instance.RegisterScepterSkill((SkillDef)(object)PathogenSpecialScepter.def, "CrocoBody", (SkillDef)(object)PathogenSpecial.def);
			if (modCompat.Paladin)
			{
				PaladinGlassShadow.SetUpScepter();
				if (unfinishedContent.Value)
				{
					PaladinResolve.SetUpScepter();
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupChef()
		{
			//IL_0024: 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_004e: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			ChefPantryPassive.ModChef();
			GameObject bodyPrefab = ChefPantryPassive.moddedSlot.bodyPrefab;
			ref Variant[] variants = ref ChefPantryPassive.moddedSlot.family.variants;
			Variant variant = new Variant
			{
				skillDef = (SkillDef)(object)ChefPantryPassive.def2
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)ChefPantryPassive.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants, variant, "ChefPantry");
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupEnforcer()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			SkillLocator component = CharacterBase.instance.bodyPrefab.GetComponent<SkillLocator>();
			object obj;
			if (component == null)
			{
				obj = null;
			}
			else
			{
				GenericSkill special = component.special;
				obj = ((special != null) ? special.skillFamily : null);
			}
			SkillFamily val = (SkillFamily)obj;
			if (Object.op_Implicit((Object)(object)val))
			{
				ref Variant[] variants = ref val.variants;
				Variant variant = new Variant
				{
					skillDef = EnforcerSundowner.def
				};
				((Variant)(ref variant)).viewableNode = new Node(EnforcerSundowner.def.skillNameToken, false, (Node)null);
				variant.unlockableDef = EnforcerUnlockables.enforcerDesperadoSkinUnlockableDef;
				ConfigAndAdd(ref variants, variant);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupSniper()
		{
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupPathfinder()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			GameObject pathfinderBodyPrefab = PathfinderPlugin.pathfinderBodyPrefab;
			ref Variant[] variants = ref pathfinderBodyPrefab.GetComponent<SkillLocator>().secondary.skillFamily.variants;
			Variant variant = new Variant
			{
				skillDef = PathfinderForcedMove.def
			};
			((Variant)(ref variant)).viewableNode = new Node(PathfinderForcedMove.def.skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants, variant, "PathfinderForcedMove", unfinished: true);
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupDeputy()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			ref Variant[] variants = ref DeputyPassive.slot.family.variants;
			Variant variant = new Variant
			{
				skillDef = (SkillDef)(object)DeputyPassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)DeputyPassive.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants, variant, "DeputyBounce");
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupGanon()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			ref Variant[] variants = ref GanonPassive.slot.family.variants;
			Variant variant = new Variant
			{
				skillDef = (SkillDef)(object)GanonPassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)GanonPassive.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants, variant, "", unfinished: true);
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupDigger()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			ref Variant[] variants = ref DiggerBlacksmithPassive.slot.family.variants;
			Variant variant = new Variant
			{
				skillDef = (SkillDef)(object)DiggerBlacksmithPassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)DiggerBlacksmithPassive.def).skillNameToken, false, (Node)null);
			variant.unlockableDef = Unlockables.blacksmithUnlockableDef;
			ConfigAndAdd(ref variants, variant, "DiggerBlacksmith");
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupHouse()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			GameObject characterPrefab = House.characterPrefab;
			SkillFamily skillFamily = characterPrefab.GetComponent<GenericSkill>().skillFamily;
			((Object)skillFamily).name = ((Object)skillFamily).name + "HouseDeck";
			HousePassive.HouseDeckDef[] defs = HousePassive.defs;
			foreach (HousePassive.HouseDeckDef houseDeckDef in defs)
			{
				ref Variant[] variants = ref skillFamily.variants;
				Variant variant = new Variant
				{
					skillDef = (SkillDef)(object)houseDeckDef
				};
				((Variant)(ref variant)).viewableNode = new Node(((SkillDef)houseDeckDef).skillNameToken, false, (Node)null);
				ConfigAndAdd(ref variants, variant, "", unfinished: true);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupRuina()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			GameObject bodyPrefab = ArgaliaPassive.slot.bodyPrefab;
			ref Variant[] variants = ref ArgaliaPassive.slot.family.variants;
			Variant variant = new Variant
			{
				skillDef = (SkillDef)(object)ArgaliaPassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)ArgaliaPassive.def).skillNameToken, false, (Node)null);
			variant.unlockableDef = RedMist.masterySkinUnlockableDef;
			ConfigAndAdd(ref variants, variant, "RuinaArgaliaPassive");
			bodyPrefab = SurvivorBase.instance.bodyPrefab;
			ref Variant[] variants2 = ref bodyPrefab.GetComponent<SkillLocator>().secondary.skillFamily.variants;
			variant = new Variant
			{
				skillDef = ArbiterBirdcage.def
			};
			((Variant)(ref variant)).viewableNode = new Node(ArbiterBirdcage.def.skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants2, variant, "RuinaArbiterBirdcage", unfinished: true);
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupRavager()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			GameObject bodyPrefab = RavagerBloodPassive.slot.bodyPrefab;
			ref Variant[] variants = ref RavagerBloodPassive.slot.family.variants;
			Variant variant = new Variant
			{
				skillDef = (SkillDef)(object)RavagerBloodPassive.def
			};
			((Variant)(ref variant)).viewableNode = new Node(((SkillDef)RavagerBloodPassive.def).skillNameToken, false, (Node)null);
			ConfigAndAdd(ref variants, variant, "RavagerBloodPassive");
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupDriver()
		{
			if (!unfinishedContent.Value)
			{
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void SetupHenry()
		{
		}
	}
}
namespace PassiveAgression.VoidSurvivor
{
	public static class InfestationPassive
	{
		public class InfestedMode : CorruptModeBase
		{
			public bool overCorrupt;

			public override void OnEnter()
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				((CorruptModeBase)this).OnEnter();
				overCorrupt = base.voidSurvivorController.minimumCorruption >= base.voidSurvivorController.maxCorruption;
				if (friendlyInfest.Value)
				{
					((Component)((EntityState)this).characterBody).GetComponent<ScriptedCombatEncounter>().teamIndex = ((EntityState)this).teamComponent.teamIndex;
				}
			}

			public override void FixedUpdate()
			{
				((EntityState)this).FixedUpdate();
				CombatSquad combatSquad = ((Component)((EntityState)this).characterBody).gameObject.GetComponent<ScriptedCombatEncounter>().combatSquad;
				if (((EntityState)this).isAuthority)
				{
					if (Object.op_Implicit((Object)(object)base.voidSurvivorController) && !overCorrupt && base.voidSurvivorController.corruption >= base.voidSurvivorController.maxCorruption && (maxInfestors.Value == -1 || combatSquad.memberCount < maxInfestors.Value) && Object.op_Implicit((Object)(object)base.voidSurvivorController.bodyStateMachine))
					{
						base.voidSurvivorController.bodyStateMachine.SetInterruptState((EntityState)(object)new ExpelInfestation(), (InterruptPriority)1);
					}
					else if (Object.op_Implicit((Object)(object)base.voidSurvivorController) && base.voidSurvivorController.minimumCorruption < base.voidSurvivorController.maxCorruption)
					{
						overCorrupt = false;
					}
				}
				if (NetworkServer.active && overCorrupt && combatSquad.defeatedServer)
				{
					base.voidSurvivorController.bodyStateMachine.SetInterruptState((EntityState)(object)new ExpelInfestation(), (InterruptPriority)1);
				}
			}
		}

		public class ExpelInfestation : CorruptionTransitionBase
		{
			private static (FieldInfo, object)[] fields;

			static ExpelInfestation()
			{
				//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_0082: Unknown result type (might be due to invalid IL or missing references)
				SerializedField[] serializedFields = Addressables.LoadAssetAsync<EntityStateConfiguration>((object)"RoR2/DLC1/VoidSurvivor/EntityStates.VoidSurvivor.EnterCorruptionTransition.asset").WaitForCompletion().serializedFieldsCollection.serializedFields;
				fields = new(FieldInfo, object)[0];
				for (int i = 0; i < serializedFields.Length; i++)
				{
					if (!(serializedFields[i].fieldName == "chargeEffectPrefab"))
					{
						FieldInfo field = typeof(ExpelInfestation).GetField(serializedFields[i].fieldName, BindingFlags.Static | BindingFlags.Public);
						if (field != null)
						{
							field.SetValue(null, serializedFields[i]);
						}
						FieldInfo field2 = typeof(ExpelInfestation).GetField(serializedFields[i].fieldName);
						if (field2 != null && ((MemberInfo)field2).GetCustomAttribute<SerializeField>() != null)
						{
							(FieldInfo, object) tuple = (field2, ((SerializedValue)(ref serializedFields[i].fieldValue)).GetValue(field2));
							ArrayUtils.ArrayAppend<(FieldInfo, object)>(ref fields, ref tuple);
						}
					}
				}
			}

			public override void OnEnter()
			{
				Type typeFromHandle = typeof(ExpelInfestation);
				(FieldInfo, object)[] array = fields;
				for (int i = 0; i < array.Length; i++)
				{
					(FieldInfo, object) tuple = array[i];
					tuple.Item1.SetValue(this, tuple.Item2);
				}
				((CorruptionTransitionBase)this).OnEnter();
			}

			public override void FixedUpdate()
			{
				((CorruptionTransitionBase)this).FixedUpdate();
				if (Object.op_Implicit((Object)(object)base.voidSurvivorController) && NetworkServer.active)
				{
					base.voidSurvivorController.AddCorruption(-100f);
				}
				if (((EntityState)this).fixedAge >= base.duration)
				{
					ScriptedCombatEncounter component = ((Component)((EntityState)this).characterBody).gameObject.GetComponent<ScriptedCombatEncounter>();
					if (NetworkServer.active)
					{
						component.BeginEncounter();
						component.hasSpawnedServer = false;
						component.combatSquad.defeatedServer = false;
					}
					if (Object.op_Implicit((Object)(object)base.voidSurvivorController))
					{
						base.voidSurvivorController.corruptionModeStateMachine.SetNextState((EntityState)(object)new InfestedMode());
					}
				}
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<Instruction, bool> <>9__6_6;

			public static Func<Instruction, bool> <>9__6_7;

			public static Func<CharacterMaster, Infest, CharacterMaster> <>9__6_4;

			public static Func<TeamIndex, Infest, CharacterMaster, TeamIndex> <>9__6_5;

			public static Func<Instruction, bool> <>9__6_9;

			public static Func<Instruction, bool> <>9__6_10;

			public static Manipulator <>9__6_2;

			public static Func<Instruction, bool> <>9__6_13;

			public static Func<Instruction, bool> <>9__6_14;

			public static Func<Instruction, bool> <>9__6_15;

			public static Func<CharacterMaster, DamageReport, CharacterMaster> <>9__6_11;

			public static Func<TeamIndex, DamageReport, TeamIndex> <>9__6_12;

			public static Manipulator <>9__6_3;

			internal BaseSkillInstanceData <.cctor>b__6_0(GenericSkill slot)
			{
				//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_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_014c: Expected O, but got Unknown
				//IL_0166: 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_0171: Expected O, but got Unknown
				ScriptedCombatEncounter val = ((Component)slot.characterBody).gameObject.AddComponent<ScriptedCombatEncounter>();
				val.spawns = spawns;
				if (friendlyInfest.Value)
				{
					val.teamIndex = slot.characterBody.teamComponent.teamIndex;
				}
				for (int i = 0; i < spawns.Length; i++)
				{
					val.spawns[i].explicitSpawnPosition = ((Component)slot.characterBody).gameObject.transform;
					val.spawns[i].cullChance /= 4f;
				}
				val.randomizeSeed = true;
				val.combatSquad = ((Component)slot.characterBody).gameObject.AddComponent<CombatSquad>();
				val.combatSquad.propagateMembershipToSummons = true;
				squads.Add(val.combatSquad);
				val.teamIndex = (TeamIndex)4;
				val.grantUniqueBonusScaling = false;
				EntityStateMachine val2 = EntityStateMachine.FindByCustomName(((Component)slot.characterBody).gameObject, "CorruptMode");
				val2.mainStateType = new SerializableEntityStateType(typeof(InfestedMode));
				val2.initialStateType = val2.mainStateType;
				if (!isHooked)
				{
					isHooked = true;
					object obj = <>9__6_2;
					if (obj == null)
					{
						Manipulator val3 = delegate(ILContext il)
						{
							//IL_0002: Unknown result type (might be due to invalid IL or missing references)
							//IL_0008: Expected O, but got Unknown
							//IL_006f: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
							ILCursor val5 = new ILCursor(il);
							MethodReference val6 = default(MethodReference);
							if (val5.TryGotoNext(new Func<Instruction, bool>[2]
							{
								(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 4),
								(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 4)
							}))
							{
								int index = val5.Index;
								val5.Index = index + 1;
								val5.Emit(OpCodes.Ldarg_0);
								val5.EmitDelegate<Func<CharacterMaster, Infest, CharacterMaster>>((Func<CharacterMaster, Infest, CharacterMaster>)delegate(CharacterMaster orig, Infest self)
								{
									<>c__DisplayClass6_0 CS$<>8__locals2 = new <>c__DisplayClass6_0
									{
										self = self
									};
									val6 = squads.Find((CombatSquad s) => s.ContainsMember(((EntityState)CS$<>8__locals2.self).characterBody.master));
									if (Object.op_Implicit((Object)(object)val6) && (Object)(object)BossGroup.FindBossGroup(orig.GetBody()) == (Object)null)
									{
										val6.AddMember(orig);
									}
									return orig;
								});
							}
							while (val5.TryGotoNext(new Func<Instruction, bool>[2]
							{
								(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 4),
								(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, ref val6)
							}))
							{
								int index = val5.Index;
								val5.Index = index + 1;
								val5.Emit(OpCodes.Ldarg_0);
								val5.Emit(OpCodes.Ldloc, 4);
								val5.EmitDelegate<Func<TeamIndex, Infest, CharacterMaster, TeamIndex>>((Func<TeamIndex, Infest, CharacterMaster, TeamIndex>)((TeamIndex orig, Infest self, CharacterMaster master) => (!friendlyInfest.Value) ? orig : (((int)((EntityState)self).teamComponent.teamIndex == 1 && (Object)(object)BossGroup.FindBossGroup(master.GetBody()) != (Object)null) ? orig : ((EntityState)self).teamComponent.teamIndex)));
							}
						};
						<>9__6_2 = val3;
						obj = (object)val3;
					}
					Infest.FixedUpdate += (Manipulator)obj;
					object obj2 = <>9__6_3;
					if (obj2 == null)
					{
						Manipulator val4 = delegate(ILContext il)
						{
							//IL_0002: Unknown result type (might be due to invalid IL or missing references)
							//IL_0008: Expected O, but got Unknown
							//IL_0091: 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 val5 = new ILCursor(il);
							if (val5.TryGotoNext(new Func<Instruction, bool>[1]
							{
								(Instruction x) => ILPatternMatchingExt.MatchLdstr(x, "RoR2/DLC1/EliteVoid/VoidInfestorMaster.prefab")
							}) && val5.TryGotoNext(new Func<Instruction, bool>[2]
							{
								(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 4),
								(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)typeof(CharacterMaster).GetProperty("teamIndex").GetSetMethod())
							}))
							{
								val5.Emit(OpCodes.Ldarg_1);
								val5.EmitDelegate<Func<CharacterMaster, DamageReport, CharacterMaster>>((Func<CharacterMaster, DamageReport, CharacterMaster>)delegate(CharacterMaster orig, DamageReport report)
								{
									<>c__DisplayClass6_1 CS$<>8__locals3 = new <>c__DisplayClass6_1
									{
										report = report
									};
									CombatSquad val6 = squads.Find((CombatSquad s) => s.ContainsMember(CS$<>8__locals3.report.victimMaster));
									if (Object.op_Implicit((Object)(object)orig) && Object.op_Implicit((Object)(object)val6))
									{
										val6.AddMember(orig);
									}
									return orig;
								});
								int index = val5.Index;
								val5.Index = index + 1;
								val5.MoveAfterLabels();
								val5.Emit(OpCodes.Ldarg_1);
								val5.EmitDelegate<Func<TeamIndex, DamageReport, TeamIndex>>((Func<TeamIndex, DamageReport, TeamIndex>)((TeamIndex orig, DamageReport report) => friendlyInfest.Value ? report.victimTeamIndex : orig));
							}
						};
						<>9__6_3 = val4;
						obj2 = (object)val4;
					}
					GlobalEventManager.OnCharacterDeath += (Manipulator)obj2;
				}
				return null;
			}

			internal void <.cctor>b__6_2(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_006f: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				MethodReference val2 = default(MethodReference);
				if (val.TryGotoNext(new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 4),
					(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 4)
				}))
				{
					int index = val.Index;
					val.Index = index + 1;
					val.Emit(OpCodes.Ldarg_0);
					val.EmitDelegate<Func<CharacterMaster, Infest, CharacterMaster>>((Func<CharacterMaster, Infest, CharacterMaster>)delegate(CharacterMaster orig, Infest self)
					{
						<>c__DisplayClass6_0 CS$<>8__locals1 = new <>c__DisplayClass6_0
						{
							self = self
						};
						val2 = squads.Find((CombatSquad s) => s.ContainsMember(((EntityState)CS$<>8__locals1.self).characterBody.master));
						if (Object.op_Implicit((Object)(object)val2) && (Object)(object)BossGroup.FindBossGroup(orig.GetBody()) == (Object)null)
						{
							val2.AddMember(orig);
						}
						return orig;
					});
				}
				while (val.TryGotoNext(new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 4),
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, ref val2)
				}))
				{
					int index = val.Index;
					val.Index = index + 1;
					val.Emit(OpCodes.Ldarg_0);
					val.Emit(OpCodes.Ldloc, 4);
					val.EmitDelegate<Func<TeamIndex, Infest, CharacterMaster, TeamIndex>>((Func<TeamIndex, Infest, CharacterMaster, TeamIndex>)((TeamIndex orig, Infest self, CharacterMaster master) => (!friendlyInfest.Value) ? orig : (((int)((EntityState)self).teamComponent.teamIndex == 1 && (Object)(object)BossGroup.FindBossGroup(master.GetBody()) != (Object)null) ? orig : ((EntityState)self).teamComponent.teamIndex)));
				}
			}

			internal bool <.cctor>b__6_6(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdloc(x, 4);
			}

			internal bool <.cctor>b__6_7(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcI4(x, 4);
			}

			internal CharacterMaster <.cctor>b__6_4(CharacterMaster orig, Infest self)
			{
				<>c__DisplayClass6_0 CS$<>8__locals1 = new <>c__DisplayClass6_0
				{
					self = self
				};
				CombatSquad val = squads.Find((CombatSquad s) => s.ContainsMember(((EntityState)CS$<>8__locals1.self).characterBody.master));
				if (Object.op_Implicit((Object)(object)val) && (Object)(object)BossGroup.FindBossGroup(orig.GetBody()) == (Object)null)
				{
					val.AddMember(orig);
				}
				return orig;
			}

			internal TeamIndex <.cctor>b__6_5(TeamIndex orig, Infest self, CharacterMaster master)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Invalid comparison between Unknown and I4
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: 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)
				return (!friendlyInfest.Value) ? orig : (((int)((EntityState)self).teamComponent.teamIndex == 1 && (Object)(object)BossGroup.FindBossGroup(master.GetBody()) != (Object)null) ? orig : ((EntityState)self).teamComponent.teamIndex);
			}

			internal bool <.cctor>b__6_9(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcI4(x, 4);
			}

			internal bool <.cctor>b__6_10(Instruction x)
			{
				MethodReference val = default(MethodReference);
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, ref val);
			}

			internal void <.cctor>b__6_3(ILContext il)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0091: 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.MatchLdstr(x, "RoR2/DLC1/EliteVoid/VoidInfestorMaster.prefab")
				}) || !val.TryGotoNext(new Func<Instruction, bool>[2]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 4),
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)typeof(CharacterMaster).GetProperty("teamIndex").GetSetMethod())
				}))
				{
					return;
				}
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Func<CharacterMaster, DamageReport, CharacterMaster>>((Func<CharacterMaster, DamageReport, CharacterMaster>)delegate(CharacterMaster orig, DamageReport report)
				{
					<>c__DisplayClass6_1 CS$<>8__locals1 = new <>c__DisplayClass6_1
					{
						report = report
					};
					CombatSquad val2 = squads.Find((CombatSquad s) => s.ContainsMember(CS$<>8__locals1.report.victimMaster));
					if (Object.op_Implicit((Object)(object)orig) && Object.op_Implicit((Object)(object)val2))
					{
						val2.AddMember(orig);
					}
					return orig;
				});
				int index = val.Index;
				val.Index = index + 1;
				val.MoveAfterLabels();
				val.Emit(OpCodes.Ldarg_1);
				val.EmitDelegate<Func<TeamIndex, DamageReport, TeamIndex>>((Func<TeamIndex, DamageReport, TeamIndex>)((TeamIndex orig, DamageReport report) => friendlyInfest.Value ? report.victimTeamIndex : orig));
			}

			internal bool <.cctor>b__6_13(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdstr(x, "RoR2/DLC1/EliteVoid/VoidInfestorMaster.prefab");
			}

			internal bool <.cctor>b__6_14(Instruction x)
			{
				return ILPatternMatchingExt.MatchLdcI4(x, 4);
			}

			internal bool <.cctor>b__6_15(Instruction x)
			{
				return ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)typeof(CharacterMaster).GetProperty("teamIndex").GetSetMethod());
			}

			internal CharacterMaster <.cctor>b__6_11(CharacterMaster orig, DamageReport report)
			{
				<>c__DisplayClass6_1 CS$<>8__locals1 = new <>c__DisplayClass6_1
				{
					report = report
				};
				CombatSquad val = squads.Find((CombatSquad s) => s.ContainsMember(CS$<>8__locals1.report.victimMaster));
				if (Object.op_Implicit((Object)(object)orig) && Object.op_Implicit((Object)(object)val))
				{
					val.AddMember(orig);
				}
				return orig;
			}

			internal TeamIndex <.cctor>b__6_12(TeamIndex orig, DamageReport report)
			{
				//IL_0010: 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)
				return friendlyInfest.Value ? report.victimTeamIndex : orig;
			}

			internal void <.cctor>b__6_1(GenericSkill slot)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type