using System;
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 System.Text;
using BepInEx;
using BepInEx.Logging;
using EntityStates;
using Microsoft.CodeAnalysis;
using On.RoR2;
using R2API;
using R2API.Utils;
using RoR2;
using RoR2.Skills;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: NetworkCompatibility(/*Could not decode attribute arguments.*/)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("VoidStance")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+71d41ee0805864580ef5297067384fa6cd5f7753")]
[assembly: AssemblyProduct("VoidStance")]
[assembly: AssemblyTitle("VoidStance")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace VoidStanceMod
{
	[BepInPlugin("com.MyName.VoidStance", "VoidStance", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public class VoidStanceToggle : BaseSkillState
		{
			public override void OnEnter()
			{
				((BaseState)this).OnEnter();
				CharacterBody characterBody = ((EntityState)this).characterBody;
				if (characterBody != null)
				{
					characterBody.SetAimTimer(0.2f);
				}
				((EntityState)this).PlayCrossfade("Gesture, Additive", "BufferEmpty", "BufferEmpty.playbackRate", 0.1f, 0.05f);
				if (!Object.op_Implicit((Object)(object)((EntityState)this).characterBody))
				{
					return;
				}
				VoidStanceController voidStanceController = ((Component)((EntityState)this).characterBody).GetComponent<VoidStanceController>();
				if (!Object.op_Implicit((Object)(object)voidStanceController))
				{
					voidStanceController = ((Component)((EntityState)this).characterBody).gameObject.AddComponent<VoidStanceController>();
				}
				if (!NetworkServer.active)
				{
					VoidStanceNet component = ((Component)((EntityState)this).characterBody).GetComponent<VoidStanceNet>();
					if ((Object)(object)component != (Object)null)
					{
						component.RequestToggle();
						return;
					}
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogWarning((object)"[VoidStance] Net component missing on client.");
					}
				}
				else
				{
					ServerToggleNow(voidStanceController);
				}
			}

			private void ServerToggleNow(VoidStanceController ctrl)
			{
				ctrl.ResolveAndBindController();
				if (ctrl.LockedIsHigh())
				{
					ctrl.GoControlledNow();
				}
				else
				{
					ctrl.GoCorruptedNow();
				}
			}

			public override void FixedUpdate()
			{
				((EntityState)this).FixedUpdate();
				if (((EntityState)this).fixedAge >= 0.2f)
				{
					((EntityState)this).outer.SetNextStateToMain();
				}
			}

			public override InterruptPriority GetMinimumInterruptPriority()
			{
				return (InterruptPriority)1;
			}
		}

		public const string PluginGUID = "com.MyName.VoidStance";

		public const string PluginName = "VoidStance";

		public const string PluginVer = "1.0.0";

		internal static ManualLogSource Log;

		internal static SkillDef StanceSkillDef;

		private string _pluginDir;

		private Sprite _modIcon;

		private Sprite _specialIcon;

		private void Awake()
		{
			//IL_0046: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: 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_01c7: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			_pluginDir = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			_modIcon = LoadSprite("icon.png");
			_specialIcon = LoadSprite("icon_special.png");
			bool flag = default(bool);
			ContentAddition.AddEntityState<VoidStanceToggle>(ref flag);
			StanceSkillDef = ScriptableObject.CreateInstance<SkillDef>();
			StanceSkillDef.skillName = "VOIDSTANCE_TOGGLE";
			StanceSkillDef.skillNameToken = "VOIDSTANCE_TOGGLE_NAME";
			StanceSkillDef.skillDescriptionToken = "VOIDSTANCE_TOGGLE_DESC";
			StanceSkillDef.icon = (((Object)(object)_specialIcon != (Object)null) ? _specialIcon : _modIcon);
			StanceSkillDef.activationState = new SerializableEntityStateType(typeof(VoidStanceToggle));
			StanceSkillDef.activationStateMachineName = "Weapon";
			StanceSkillDef.baseMaxStock = 1;
			StanceSkillDef.rechargeStock = 1;
			StanceSkillDef.baseRechargeInterval = 2f;
			StanceSkillDef.beginSkillCooldownOnSkillEnd = true;
			StanceSkillDef.canceledFromSprinting = false;
			StanceSkillDef.cancelSprintingOnActivation = false;
			StanceSkillDef.fullRestockOnAssign = true;
			StanceSkillDef.isCombatSkill = true;
			StanceSkillDef.interruptPriority = (InterruptPriority)0;
			StanceSkillDef.mustKeyPress = true;
			StanceSkillDef.requiredStock = 1;
			StanceSkillDef.resetCooldownTimerOnUse = false;
			ContentAddition.AddSkillDef(StanceSkillDef);
			LanguageAPI.Add("VOIDSTANCE_TOGGLE_NAME", "Void Stance");
			LanguageAPI.Add("VOIDSTANCE_TOGGLE_DESC", "Toggle between Controlled and Corrupted at will. Prevents passive corruption drift and auto-transforms.");
			RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, new Action(InjectIntoVoidFiend));
			CharacterBody.onBodyStartGlobal += TryAttachControllers;
			CharacterBody.Start += new hook_Start(HookBodyStartAttach);
			Log.LogInfo((object)"[VoidStance] Loaded 1.3.3");
		}

		private Sprite LoadSprite(string fileName)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_008c: 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)
			try
			{
				if (string.IsNullOrEmpty(_pluginDir))
				{
					return null;
				}
				string path = Path.Combine(_pluginDir, fileName);
				if (!File.Exists(path))
				{
					return null;
				}
				byte[] array = File.ReadAllBytes(path);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!ImageConversion.LoadImage(val, array))
				{
					return null;
				}
				((Texture)val).wrapMode = (TextureWrapMode)1;
				((Texture)val).filterMode = (FilterMode)1;
				return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("[VoidStance] LoadSprite failed for '" + fileName + "': " + ex.Message));
				}
				return null;
			}
		}

		private void InjectIntoVoidFiend()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: 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_011d: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSurvivor/VoidSurvivorBody.prefab").WaitForCompletion();
				if (!Object.op_Implicit((Object)(object)val))
				{
					Log.LogError((object)"[VoidStance] Could not load VoidSurvivorBody.");
					return;
				}
				SkillLocator component = val.GetComponent<SkillLocator>();
				if (!Object.op_Implicit((Object)(object)component) || !Object.op_Implicit((Object)(object)component.special) || !Object.op_Implicit((Object)(object)component.special.skillFamily))
				{
					Log.LogError((object)"[VoidStance] Void Fiend special family not found.");
					return;
				}
				SkillFamily skillFamily = component.special.skillFamily;
				if (!skillFamily.variants.Any((Variant v) => (Object)(object)v.skillDef == (Object)(object)StanceSkillDef))
				{
					Array.Resize(ref skillFamily.variants, skillFamily.variants.Length + 1);
					Variant[] variants = skillFamily.variants;
					int num = variants.Length - 1;
					Variant val2 = new Variant
					{
						skillDef = StanceSkillDef,
						unlockableDef = null
					};
					((Variant)(ref val2)).viewableNode = new Node(StanceSkillDef.skillNameToken, false, (Node)null);
					variants[num] = val2;
				}
				Log.LogInfo((object)"[VoidStance] Added 'Void Stance' to Void Fiend Special.");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[VoidStance] Injection failed: " + ex));
			}
		}

		private void HookBodyStartAttach(orig_Start orig, CharacterBody self)
		{
			orig.Invoke(self);
			TryAttachControllers(self);
		}

		private void TryAttachControllers(CharacterBody body)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)body))
			{
				return;
			}
			if ((!Object.op_Implicit((Object)(object)((Component)body).gameObject) || ((Object)((Component)body).gameObject).name.IndexOf("VoidSurvivor", StringComparison.OrdinalIgnoreCase) < 0) && (string.IsNullOrEmpty(body.baseNameToken) || body.baseNameToken.IndexOf("VOID_SURVIVOR", StringComparison.OrdinalIgnoreCase) < 0))
			{
				string bodyName = BodyCatalog.GetBodyName(body.bodyIndex);
				if (bodyName == null || bodyName.IndexOf("VoidSurvivor", StringComparison.OrdinalIgnoreCase) < 0)
				{
					return;
				}
			}
			if (!Object.op_Implicit((Object)(object)((Component)body).GetComponent<VoidStanceController>()))
			{
				((Component)body).gameObject.AddComponent<VoidStanceController>();
			}
			if (!Object.op_Implicit((Object)(object)((Component)body).GetComponent<VoidStanceNet>()))
			{
				((Component)body).gameObject.AddComponent<VoidStanceNet>();
			}
		}
	}
	public class VoidStanceNet : NetworkBehaviour
	{
		private CharacterBody body;

		private VoidStanceController ctrl;

		private void Awake()
		{
			body = ((Component)this).GetComponent<CharacterBody>();
			ctrl = ((Component)this).GetComponent<VoidStanceController>();
		}

		public void RequestToggle()
		{
			if (!((NetworkBehaviour)this).isServer)
			{
				CmdToggle();
			}
			else
			{
				ServerToggle();
			}
		}

		[Command]
		private void CmdToggle()
		{
			ServerToggle();
		}

		private void ServerToggle()
		{
			if (!Object.op_Implicit((Object)(object)ctrl))
			{
				ctrl = ((Component)this).GetComponent<VoidStanceController>();
			}
			if (Object.op_Implicit((Object)(object)ctrl))
			{
				ctrl.ResolveAndBindController();
				if (ctrl.LockedIsHigh())
				{
					ctrl.GoControlledNow();
				}
				else
				{
					ctrl.GoCorruptedNow();
				}
				TargetOnToggled(((NetworkBehaviour)this).connectionToClient, ctrl.LockedIsHigh());
			}
		}

		[TargetRpc]
		private void TargetOnToggled(NetworkConnection target, bool isCorrupted)
		{
		}
	}
	public class VoidStanceController : MonoBehaviour
	{
		private CharacterBody body;

		private GenericSkill special;

		private Component vfController;

		private Transform boundTransform;

		private FieldInfo fldCorruption;

		private PropertyInfo propCorruption;

		private FieldInfo fldIsCorrupted;

		private FieldInfo fldCorruptionActive;

		private FieldInfo fldMinThreshold;

		private FieldInfo fldMaxThreshold;

		private FieldInfo[] corruptionRelatedFloats;

		private MethodInfo mEnterCorruption;

		private MethodInfo mExitCorruption;

		private MethodInfo mSetCorruptionActiveBool;

		private MethodInfo mTryTransformToCorrupted;

		private MethodInfo mTryTransformToBase;

		private MethodInfo mRequestTransformationBool;

		private float lockedCorruption = float.NaN;

		private bool corruptionIsPercent = true;

		private bool userChoseStance;

		private bool overrideApplied;

		private float rebindTick;

		private bool dumped;

		private void Start()
		{
			body = ((Component)this).GetComponent<CharacterBody>();
			CharacterBody obj = body;
			special = ((obj == null) ? null : obj.skillLocator?.special);
			userChoseStance = HasVoidStanceSelected();
			ResolveAndBindController();
			SnapLockValue();
		}

		private void OnDestroy()
		{
			TryUnsetOverride();
		}

		private bool HasVoidStanceSelected()
		{
			if (!Object.op_Implicit((Object)(object)special) || (Object)(object)Plugin.StanceSkillDef == (Object)null)
			{
				return false;
			}
			return (Object)(object)special.skillDef == (Object)(object)Plugin.StanceSkillDef;
		}

		private bool FamilyContainsOurDef()
		{
			if (!Object.op_Implicit((Object)(object)special) || (Object)(object)special.skillFamily == (Object)null || (Object)(object)Plugin.StanceSkillDef == (Object)null)
			{
				return false;
			}
			SkillFamily skillFamily = special.skillFamily;
			for (int i = 0; i < skillFamily.variants.Length; i++)
			{
				if ((Object)(object)skillFamily.variants[i].skillDef == (Object)(object)Plugin.StanceSkillDef)
				{
					return true;
				}
			}
			return false;
		}

		private void TryApplyOverride()
		{
			if (!overrideApplied && Object.op_Implicit((Object)(object)special) && !((Object)(object)Plugin.StanceSkillDef == (Object)null) && FamilyContainsOurDef())
			{
				special.SetSkillOverride((object)body, Plugin.StanceSkillDef, (SkillOverridePriority)4);
				overrideApplied = true;
			}
		}

		private void TryUnsetOverride()
		{
			if (overrideApplied)
			{
				if (!Object.op_Implicit((Object)(object)special) || (Object)(object)Plugin.StanceSkillDef == (Object)null)
				{
					overrideApplied = false;
					return;
				}
				special.UnsetSkillOverride((object)body, Plugin.StanceSkillDef, (SkillOverridePriority)4);
				overrideApplied = false;
			}
		}

		public void ForceDump()
		{
			DumpAllComponents();
		}

		private void FixedUpdate()
		{
			rebindTick -= Time.fixedDeltaTime;
			if (rebindTick <= 0f)
			{
				rebindTick = 0.1f;
				if (!Object.op_Implicit((Object)(object)vfController))
				{
					ResolveAndBindController();
				}
			}
			if (HasVoidStanceSelected())
			{
				userChoseStance = true;
			}
			if (userChoseStance)
			{
				TryApplyOverride();
			}
			else
			{
				TryUnsetOverride();
			}
			if (NetworkServer.active && Object.op_Implicit((Object)(object)vfController) && userChoseStance)
			{
				StrongLockCorruption();
			}
		}

		private void Update()
		{
			if (NetworkServer.active && Object.op_Implicit((Object)(object)vfController) && userChoseStance)
			{
				StrongLockCorruption();
			}
		}

		public bool LockedIsHigh()
		{
			if (float.IsNaN(lockedCorruption))
			{
				lockedCorruption = ReadCorruption();
			}
			float num = (float.IsNaN(lockedCorruption) ? 0f : lockedCorruption);
			return num > (corruptionIsPercent ? 50f : 0.5f);
		}

		public void GoCorruptedNow()
		{
			ResolveAndBindController();
			if (HasVoidStanceSelected())
			{
				userChoseStance = true;
			}
			if (userChoseStance)
			{
				TryApplyOverride();
			}
			SafeInvoke(mSetCorruptionActiveBool, vfController, new object[1] { false });
			SafeInvoke(mEnterCorruption, vfController, null);
			SafeInvoke(mTryTransformToCorrupted, vfController, null);
			SafeInvoke(mRequestTransformationBool, vfController, new object[1] { true });
			SafeWriteBool(fldIsCorrupted, vfController, v: true);
			SafeWriteBool(fldCorruptionActive, vfController, v: false);
			lockedCorruption = (corruptionIsPercent ? 100f : 1f);
			WriteCorruption(lockedCorruption);
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"[VoidStance] -> Corrupted");
			}
		}

		public void GoControlledNow()
		{
			ResolveAndBindController();
			if (HasVoidStanceSelected())
			{
				userChoseStance = true;
			}
			if (userChoseStance)
			{
				TryApplyOverride();
			}
			SafeInvoke(mSetCorruptionActiveBool, vfController, new object[1] { false });
			SafeInvoke(mExitCorruption, vfController, null);
			SafeInvoke(mTryTransformToBase, vfController, null);
			SafeInvoke(mRequestTransformationBool, vfController, new object[1] { false });
			SafeWriteBool(fldIsCorrupted, vfController, v: false);
			SafeWriteBool(fldCorruptionActive, vfController, v: false);
			lockedCorruption = 0f;
			WriteCorruption(lockedCorruption);
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"[VoidStance] -> Controlled");
			}
		}

		public void ResolveAndBindController()
		{
			vfController = null;
			boundTransform = null;
			fldCorruption = null;
			propCorruption = null;
			fldIsCorrupted = null;
			fldCorruptionActive = null;
			fldMinThreshold = null;
			fldMaxThreshold = null;
			corruptionRelatedFloats = null;
			mEnterCorruption = null;
			mExitCorruption = null;
			mSetCorruptionActiveBool = null;
			mTryTransformToCorrupted = null;
			mTryTransformToBase = null;
			mRequestTransformationBool = null;
			if (!Object.op_Implicit((Object)(object)body))
			{
				return;
			}
			List<Transform> list = new List<Transform> { body.transform };
			ModelLocator modelLocator = body.modelLocator;
			if (Object.op_Implicit((Object)(object)modelLocator) && Object.op_Implicit((Object)(object)modelLocator.modelTransform))
			{
				list.Add(modelLocator.modelTransform);
			}
			if (Object.op_Implicit((Object)(object)modelLocator) && Object.op_Implicit((Object)(object)modelLocator.modelBaseTransform))
			{
				list.Add(modelLocator.modelBaseTransform);
			}
			if (Object.op_Implicit((Object)(object)body.masterObject))
			{
				list.Add(body.masterObject.transform);
			}
			foreach (Transform item in list.Where((Transform x) => Object.op_Implicit((Object)(object)x)))
			{
				Component[] componentsInChildren = ((Component)item).GetComponentsInChildren<Component>(true);
				foreach (Component val in componentsInChildren)
				{
					if (Object.op_Implicit((Object)(object)val) && ((object)val).GetType().Name.Equals("VoidSurvivorController", StringComparison.OrdinalIgnoreCase) && BindFromComponent(val))
					{
						return;
					}
				}
			}
			foreach (Transform item2 in list.Where((Transform x) => Object.op_Implicit((Object)(object)x)))
			{
				Component[] componentsInChildren2 = ((Component)item2).GetComponentsInChildren<Component>(true);
				foreach (Component val2 in componentsInChildren2)
				{
					if (Object.op_Implicit((Object)(object)val2))
					{
						Type type = ((object)val2).GetType();
						if (HasAnyMethod(type, new string[10] { "EnterCorruption", "EnterCorrupted", "StartCorruption", "ExitCorruption", "ExitCorrupted", "StopCorruption", "SetCorruptionActive", "TryTransformToCorrupted", "TryTransformToBase", "RequestTransformation" }) && BindFromComponent(val2))
						{
							return;
						}
					}
				}
			}
			foreach (Transform item3 in list.Where((Transform x) => Object.op_Implicit((Object)(object)x)))
			{
				Component[] componentsInChildren3 = ((Component)item3).GetComponentsInChildren<Component>(true);
				foreach (Component val3 in componentsInChildren3)
				{
					if (Object.op_Implicit((Object)(object)val3) && HasPlausibleCorruptionValue(val3, out var _, out var _) && BindFromComponent(val3))
					{
						return;
					}
				}
			}
			if (!dumped)
			{
				dumped = true;
				DumpAllComponents();
			}
		}

		private bool BindFromComponent(Component c)
		{
			vfController = c;
			boundTransform = c.transform;
			Type type = ((object)c).GetType();
			fldCorruption = FirstField(type, typeof(float), new string[5] { "corruption", "corruptionFrac", "corruptionFraction", "corruptionPercent", "corruptionValue" }) ?? GuessCorruptionFloatField(type, c);
			if (fldCorruption == null)
			{
				propCorruption = FirstProperty(type, typeof(float), new string[4] { "Corruption", "CorruptionFraction", "CorruptionPercent", "Value" });
			}
			fldIsCorrupted = FirstField(type, typeof(bool), new string[4] { "isCorrupted", "isCorruption", "corrupted", "isInCorruptedMode" });
			fldCorruptionActive = FirstField(type, typeof(bool), new string[3] { "corruptionActive", "isCorruptionActive", "isCorruptionOn" });
			fldMinThreshold = FirstField(type, typeof(float), new string[3] { "minCorruptionToTransform", "minCorruptionToActivate", "minCorruption" });
			fldMaxThreshold = FirstField(type, typeof(float), new string[3] { "maxCorruptionToRevert", "maxCorruptionToDeactivate", "maxCorruption" });
			FieldInfo[] array = (from f in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				where f.FieldType == typeof(float)
				select f).ToArray();
			List<FieldInfo> list = new List<FieldInfo>();
			FieldInfo[] array2 = array;
			foreach (FieldInfo fieldInfo in array2)
			{
				string text = fieldInfo.Name.ToLowerInvariant();
				if (text.Contains("corrupt") && ShouldZero(fieldInfo))
				{
					list.Add(fieldInfo);
				}
			}
			corruptionRelatedFloats = list.ToArray();
			mEnterCorruption = FirstMethod(type, new string[3] { "EnterCorruption", "EnterCorrupted", "StartCorruption" }, Type.EmptyTypes);
			mExitCorruption = FirstMethod(type, new string[3] { "ExitCorruption", "ExitCorrupted", "StopCorruption" }, Type.EmptyTypes);
			mSetCorruptionActiveBool = FirstMethod(type, new string[2] { "SetCorruptionActive", "SetCorrupted" }, new Type[1] { typeof(bool) });
			mTryTransformToCorrupted = FirstMethod(type, new string[2] { "TryTransformToCorrupted", "TryEnterCorruption" }, Type.EmptyTypes);
			mTryTransformToBase = FirstMethod(type, new string[2] { "TryTransformToBase", "TryExitCorruption" }, Type.EmptyTypes);
			mRequestTransformationBool = FirstMethod(type, new string[2] { "RequestTransformation", "RequestCorruption" }, new Type[1] { typeof(bool) });
			float num = ReadCorruption();
			if (!float.IsNaN(num))
			{
				corruptionIsPercent = num > 1.0001f && num <= 100f;
			}
			else
			{
				corruptionIsPercent = false;
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				object[] obj = new object[4]
				{
					type.FullName,
					PathOf(boundTransform),
					fldCorruption?.Name ?? propCorruption?.Name ?? "<?>",
					null
				};
				FieldInfo[] array3 = corruptionRelatedFloats;
				obj[3] = ((array3 != null) ? array3.Length : 0);
				log.LogInfo((object)string.Format("[VoidStance] Bound: {0} @ {1} | value={2} | floatsToZero={3}", obj));
			}
			return true;
			bool ShouldZero(FieldInfo f)
			{
				string text2 = f.Name.ToLowerInvariant();
				if (fldCorruption != null && f == fldCorruption)
				{
					return false;
				}
				if (text2.Contains("min") || text2.Contains("max") || text2.Contains("threshold") || text2.Contains("limit") || text2.Contains("bound"))
				{
					return false;
				}
				if (text2.Contains("toactivate") || text2.Contains("totransform"))
				{
					return false;
				}
				if (text2.EndsWith("percent") || text2.EndsWith("fraction") || text2.EndsWith("value"))
				{
					return false;
				}
				return text2.Contains("rate") || text2.Contains("drift") || text2.Contains("delta") || text2.Contains("speed") || text2.Contains("gain") || text2.Contains("loss") || text2.Contains("regen") || text2.Contains("persecond");
			}
		}

		private void StrongLockCorruption()
		{
			if (float.IsNaN(lockedCorruption))
			{
				lockedCorruption = ReadCorruption();
			}
			if (float.IsNaN(lockedCorruption))
			{
				lockedCorruption = 0f;
			}
			if (corruptionIsPercent)
			{
				lockedCorruption = Mathf.Clamp(lockedCorruption, 0f, 100f);
			}
			else
			{
				lockedCorruption = Mathf.Clamp01(lockedCorruption);
			}
			WriteCorruption(lockedCorruption);
			SafeInvoke(mSetCorruptionActiveBool, vfController, new object[1] { false });
			if (corruptionRelatedFloats != null)
			{
				for (int i = 0; i < corruptionRelatedFloats.Length; i++)
				{
					SafeWriteFloat(corruptionRelatedFloats[i], vfController, 0f);
				}
			}
		}

		private void DumpAllComponents()
		{
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("=== VoidStance Component Dump ===");
				CharacterBody obj = body;
				ModelLocator val = ((obj != null) ? obj.modelLocator : null);
				List<Transform> list = new List<Transform>();
				if (Object.op_Implicit((Object)(object)body))
				{
					list.Add(body.transform);
				}
				if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.modelTransform))
				{
					list.Add(val.modelTransform);
				}
				if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.modelBaseTransform))
				{
					list.Add(val.modelBaseTransform);
				}
				if (Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)body.masterObject))
				{
					list.Add(body.masterObject.transform);
				}
				foreach (Transform item in list.Where((Transform x) => Object.op_Implicit((Object)(object)x)))
				{
					stringBuilder.AppendLine("-- ROOT: " + PathOf(item));
					Component[] componentsInChildren = ((Component)item).GetComponentsInChildren<Component>(true);
					foreach (Component val2 in componentsInChildren)
					{
						if (Object.op_Implicit((Object)(object)val2))
						{
							Type type = ((object)val2).GetType();
							stringBuilder.AppendLine("  " + PathOf(val2.transform) + "  ::  " + type.FullName);
							if (HasAnyMethod(type, new string[6] { "EnterCorruption", "ExitCorruption", "SetCorruptionActive", "TryTransformToCorrupted", "TryTransformToBase", "RequestTransformation" }))
							{
								stringBuilder.AppendLine("    [*] has corruption methods");
							}
							if (HasPlausibleCorruptionValue(val2, out var fOut, out var pOut))
							{
								stringBuilder.AppendLine("    [*] has corruption value via " + ((fOut != null) ? ("field:" + fOut.Name) : ("prop:" + pOut.Name)));
							}
						}
					}
				}
				string text = Path.Combine(Paths.BepInExRootPath, "LogOutput");
				Directory.CreateDirectory(text);
				string text2 = Path.Combine(text, "VoidStance.dump.txt");
				File.WriteAllText(text2, stringBuilder.ToString());
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[VoidStance] Dump written: " + text2));
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[VoidStance] Dump failed: " + ex.Message));
				}
			}
		}

		private static bool HasAnyMethod(Type t, IEnumerable<string> names)
		{
			foreach (string name in names)
			{
				if (t.GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) != null)
				{
					return true;
				}
			}
			return false;
		}

		private static bool HasPlausibleCorruptionValue(Component c, out FieldInfo fOut, out PropertyInfo pOut)
		{
			fOut = null;
			pOut = null;
			Type type = ((object)c).GetType();
			FieldInfo fieldInfo = FirstField(type, typeof(float), new string[5] { "corruption", "corruptionFraction", "corruptionFrac", "corruptionPercent", "corruptionValue" }) ?? GuessCorruptionFloatField(type, c);
			PropertyInfo propertyInfo = null;
			if (fieldInfo == null)
			{
				propertyInfo = FirstProperty(type, typeof(float), new string[4] { "Corruption", "CorruptionFraction", "CorruptionPercent", "Value" });
			}
			float num = float.NaN;
			try
			{
				if (fieldInfo != null)
				{
					num = (float)fieldInfo.GetValue(c);
				}
				else if (propertyInfo != null)
				{
					num = (float)propertyInfo.GetValue(c, null);
				}
			}
			catch
			{
			}
			if (!float.IsNaN(num) && ((num >= 0f && num <= 1f) || (num >= 0f && num <= 100f)))
			{
				fOut = fieldInfo;
				pOut = propertyInfo;
				return true;
			}
			return false;
		}

		private static FieldInfo FirstField(Type t, Type ft, IEnumerable<string> names)
		{
			foreach (string name in names)
			{
				FieldInfo field = t.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null && field.FieldType == ft)
				{
					return field;
				}
			}
			return null;
		}

		private static PropertyInfo FirstProperty(Type t, Type pt, IEnumerable<string> names)
		{
			foreach (string name in names)
			{
				PropertyInfo property = t.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null && property.PropertyType == pt && property.CanRead && property.CanWrite)
				{
					return property;
				}
			}
			return null;
		}

		private static MethodInfo FirstMethod(Type t, IEnumerable<string> names, Type[] sig)
		{
			foreach (string name in names)
			{
				MethodInfo method = t.GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, sig, null);
				if (method != null)
				{
					return method;
				}
			}
			return null;
		}

		private static MethodInfo FirstMethod(Type t, IEnumerable<string> names, Type emptySig)
		{
			return FirstMethod(t, names, Type.EmptyTypes);
		}

		private static FieldInfo GuessCorruptionFloatField(Type t, object inst)
		{
			try
			{
				FieldInfo[] array = (from f in t.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
					where f.FieldType == typeof(float)
					select f).ToArray();
				FieldInfo[] array2 = array.Where((FieldInfo f) => f.Name.IndexOf("corrupt", StringComparison.OrdinalIgnoreCase) >= 0).ToArray();
				FieldInfo[] array3 = ((array2.Length != 0) ? array2 : array);
				FieldInfo[] array4 = array3;
				foreach (FieldInfo fieldInfo in array4)
				{
					try
					{
						float num = (float)fieldInfo.GetValue(inst);
						if ((num >= 0f && num <= 1f) || (num >= 0f && num <= 100f))
						{
							return fieldInfo;
						}
					}
					catch
					{
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private float ReadCorruption()
		{
			try
			{
				if (fldCorruption != null)
				{
					return (float)fldCorruption.GetValue(vfController);
				}
				if (propCorruption != null)
				{
					return (float)propCorruption.GetValue(vfController, null);
				}
			}
			catch
			{
			}
			return float.NaN;
		}

		private void WriteCorruption(float value)
		{
			try
			{
				if (fldCorruption != null)
				{
					fldCorruption.SetValue(vfController, value);
				}
				else if (propCorruption != null)
				{
					propCorruption.SetValue(vfController, value, null);
				}
			}
			catch
			{
			}
		}

		private void SafeWriteFloat(FieldInfo f, object o, float v)
		{
			if (f == null)
			{
				return;
			}
			try
			{
				f.SetValue(o, v);
			}
			catch
			{
			}
		}

		private void SafeWriteBool(FieldInfo f, object o, bool v)
		{
			if (f == null)
			{
				return;
			}
			try
			{
				f.SetValue(o, v);
			}
			catch
			{
			}
		}

		private bool? ReadBool(FieldInfo f, object o)
		{
			if (f == null)
			{
				return null;
			}
			try
			{
				return (bool)f.GetValue(o);
			}
			catch
			{
				return null;
			}
		}

		private bool SafeInvoke(MethodInfo m, object o, object[] args)
		{
			if (m == null)
			{
				return false;
			}
			try
			{
				m.Invoke(o, args);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static string PathOf(Transform t)
		{
			if (!Object.op_Implicit((Object)(object)t))
			{
				return "<null>";
			}
			List<string> list = new List<string>();
			while (Object.op_Implicit((Object)(object)t))
			{
				list.Add(((Object)t).name);
				t = t.parent;
			}
			list.Reverse();
			return string.Join("/", list);
		}

		private void SnapLockValue()
		{
			bool? flag = ReadBool(fldIsCorrupted, vfController);
			if (flag.HasValue)
			{
				lockedCorruption = ((!flag.Value) ? 0f : (corruptionIsPercent ? 100f : 1f));
				WriteCorruption(lockedCorruption);
				return;
			}
			float num = ReadCorruption();
			if (float.IsNaN(num))
			{
				num = 0f;
			}
			if (num < 0f)
			{
				num = 0f;
			}
			if (num > 100f)
			{
				num = 100f;
			}
			if (num <= 1.0001f)
			{
				corruptionIsPercent = false;
			}
			else if (num <= 100f)
			{
				corruptionIsPercent = true;
			}
			lockedCorruption = num;
		}
	}
}
namespace VoidStance
{
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
}