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 AbsoluteVirtueSurvivor.Buffs;
using AbsoluteVirtueSurvivor.Character;
using AbsoluteVirtueSurvivor.Character.Master;
using AbsoluteVirtueSurvivor.Character.States;
using AbsoluteVirtueSurvivor.Character.Survivor;
using AbsoluteVirtueSurvivor.Core;
using AbsoluteVirtueSurvivor.Skills;
using AbsoluteVirtueSurvivor.Skills.Abilities;
using AbsoluteVirtueSurvivor.Skills.Magic;
using AbsoluteVirtueSurvivor.Skills.Polearm;
using AbsoluteVirtueSurvivor.Sound;
using AbsoluteVirtueSurvivor.Vfx;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using HG.BlendableTypes;
using Microsoft.CodeAnalysis;
using On.RoR2;
using R2API;
using Rewired;
using RoR2;
using RoR2.ContentManagement;
using RoR2.Skills;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using XiVfx.Format;
using XiVfx.Unity;
using XiVfx.Unity.Practical;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("AbsoluteVirtueSurvivor")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("AbsoluteVirtueSurvivor")]
[assembly: AssemblyTitle("AbsoluteVirtueSurvivor")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 AbsoluteVirtueSurvivor
{
	[BepInPlugin("com.abyssano78.absolutevirtuesurvivor", "AbsoluteVirtueSurvivor", "1.0.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.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Action<DamageReport> <0>__OnTakeDamage;

			public static hook_TakeDamageProcess <1>__HalveDamageOverTime;
		}

		public const string PluginGuid = "com.abyssano78.absolutevirtuesurvivor";

		public const string PluginName = "AbsoluteVirtueSurvivor";

		public const string PluginVersion = "1.0.1";

		private AssetBundle _assetBundle;

		private AssetBundle _vfxBundle;

		private void Awake()
		{
			//IL_013a: 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_0145: Expected O, but got Unknown
			Log.Init(((BaseUnityPlugin)this).Logger);
			AVConfig.Init(((BaseUnityPlugin)this).Config);
			string text = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location) ?? string.Empty;
			_assetBundle = LoadBundle(text, "absolutevirtueassets");
			if ((Object)(object)_assetBundle == (Object)null)
			{
				return;
			}
			GameObject val = _assetBundle.LoadAsset<GameObject>("AbsoluteVirtue");
			if ((Object)(object)val == (Object)null)
			{
				Log.Error("Could not find a GameObject named AbsoluteVirtue in the AssetBundle.");
				return;
			}
			AVIcons.Init(_assetBundle);
			try
			{
				Log.Info("XiVFX runtime: " + typeof(XiEffectAsset).Assembly.GetName().Version);
				_vfxBundle = LoadBundle(text, "avvfx");
				if ((Object)(object)_vfxBundle != (Object)null)
				{
					AVVfx.Init(_vfxBundle);
				}
			}
			catch (Exception ex)
			{
				Log.Error("FFXI effects unavailable: " + ex);
			}
			AVSound.Init(text);
			AVBuffs.Init();
			GlobalEventManager.onServerDamageDealt += AVLifecycle.OnTakeDamage;
			object obj = <>O.<1>__HalveDamageOverTime;
			if (obj == null)
			{
				hook_TakeDamageProcess val2 = AVLifecycle.HalveDamageOverTime;
				<>O.<1>__HalveDamageOverTime = val2;
				obj = (object)val2;
			}
			HealthComponent.TakeDamageProcess += (hook_TakeDamageProcess)obj;
			try
			{
				if (AVBody.Initialize(val) && AVPolearmSkills.Initialize(AVBody.BodyPrefab) && AVSkills.Initialize(AVBody.BodyPrefab) && AVMaster.Initialize() && AVSurvivor.Initialize())
				{
					AVContentPackProvider.Register();
					Log.Info("Absolute Virtue survivor content prepared.");
				}
				else
				{
					Log.Error("Absolute Virtue survivor setup did not complete.");
				}
			}
			catch (Exception ex2)
			{
				Log.Error("Absolute Virtue survivor initialization failed: " + ex2);
			}
		}

		private static AssetBundle LoadBundle(string directory, string name)
		{
			string text = Path.Combine(directory, name);
			if (!File.Exists(text))
			{
				Log.Error("AssetBundle " + name + " was not found beside the plugin DLL.");
				return null;
			}
			AssetBundle obj = AssetBundle.LoadFromFile(text);
			if ((Object)(object)obj == (Object)null)
			{
				Log.Error("AssetBundle.LoadFromFile(" + name + ") returned null.");
			}
			return obj;
		}

		private void OnDestroy()
		{
			if ((Object)(object)_assetBundle != (Object)null)
			{
				_assetBundle.Unload(false);
			}
			if ((Object)(object)_vfxBundle != (Object)null)
			{
				_vfxBundle.Unload(false);
			}
		}
	}
	internal static class Log
	{
		private static ManualLogSource source;

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

		internal static void Info(object data)
		{
			ManualLogSource obj = source;
			if (obj != null)
			{
				obj.LogInfo(data);
			}
		}

		internal static void Warning(object data)
		{
			ManualLogSource obj = source;
			if (obj != null)
			{
				obj.LogWarning(data);
			}
		}

		internal static void Error(object data)
		{
			ManualLogSource obj = source;
			if (obj != null)
			{
				obj.LogError(data);
			}
		}

		internal static void Debug(object data)
		{
			ManualLogSource obj = source;
			if (obj != null)
			{
				obj.LogDebug(data);
			}
		}
	}
}
namespace AbsoluteVirtueSurvivor.Vfx
{
	internal sealed class AVActorLook : IDisposable
	{
		private sealed class ColorLerp
		{
			public Color32 From;

			public Color32 To;

			public int Duration;

			public int Elapsed;
		}

		private sealed class UvLerp
		{
			public float From;

			public float To;

			public int Axis;

			public int Duration;

			public int Elapsed;
		}

		private sealed class Lifetime
		{
			public int Duration;

			public int Elapsed;
		}

		private static readonly Color32 NeutralFade = new Color32((byte)128, (byte)128, (byte)128, (byte)128);

		private Color32 wrapColor;

		private Vector2 wrapUv;

		private Texture2D wrapTexture;

		private Color32 fadeColor = NeutralFade;

		private readonly List<ColorLerp> wrapColors = new List<ColorLerp>();

		private readonly List<UvLerp> wrapUvs = new List<UvLerp>();

		private readonly List<Lifetime> textures = new List<Lifetime>();

		private readonly List<ColorLerp> fades = new List<ColorLerp>();

		private readonly List<SkinnedMeshRenderer> wrapRenderers = new List<SkinnedMeshRenderer>();

		private readonly List<SkinnedMeshRenderer> fadeRenderers = new List<SkinnedMeshRenderer>();

		private Material wrapMaterial;

		private Material fadeMaterial;

		internal void Attach(Transform visual)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			if (Object.op_Implicit((Object)(object)AVVfx.WrapOverlayMaterial))
			{
				wrapMaterial = new Material(AVVfx.WrapOverlayMaterial);
			}
			if (Object.op_Implicit((Object)(object)AVVfx.FadeOverlayMaterial))
			{
				fadeMaterial = new Material(AVVfx.FadeOverlayMaterial);
			}
			SkinnedMeshRenderer[] componentsInChildren = ((Component)visual).GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				if (!((Object)(object)val.sharedMesh == (Object)null))
				{
					if (Object.op_Implicit((Object)(object)wrapMaterial))
					{
						wrapRenderers.Add(Clone(val, "FFXI wrap", wrapMaterial));
					}
					if (Object.op_Implicit((Object)(object)fadeMaterial))
					{
						fadeRenderers.Add(Clone(val, "FFXI fade", fadeMaterial));
					}
				}
			}
		}

		private static SkinnedMeshRenderer Clone(SkinnedMeshRenderer source, string suffix, Material material)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0039: 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_004f: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(((Object)source).name + " " + suffix);
			val.transform.SetParent(((Component)source).transform.parent, false);
			val.transform.localPosition = ((Component)source).transform.localPosition;
			val.transform.localRotation = ((Component)source).transform.localRotation;
			val.transform.localScale = ((Component)source).transform.localScale;
			SkinnedMeshRenderer val2 = val.AddComponent<SkinnedMeshRenderer>();
			val2.sharedMesh = source.sharedMesh;
			val2.bones = source.bones;
			val2.rootBone = source.rootBone;
			val2.updateWhenOffscreen = true;
			((Renderer)val2).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)val2).receiveShadows = false;
			Material[] array = (Material[])(object)new Material[((Renderer)source).sharedMaterials.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = material;
			}
			((Renderer)val2).sharedMaterials = array;
			((Renderer)val2).enabled = false;
			return val2;
		}

		internal void Apply(XiFfxiActorCommand command)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected I4, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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_010c: 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_0032: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			XiFfxiActorCommandKind kind = command.Kind;
			switch (kind - 5)
			{
			case 3:
				wrapColors.Add(new ColorLerp
				{
					From = wrapColor,
					To = Argb(command.PackedColorRgba),
					Duration = command.DurationTicks
				});
				break;
			case 2:
				wrapUvs.Add(new UvLerp
				{
					From = ((command.WrapUvAxis == 0) ? wrapUv.x : wrapUv.y),
					To = command.WrapUvEndpoint,
					Axis = command.WrapUvAxis,
					Duration = command.DurationTicks
				});
				break;
			case 1:
				wrapTexture = FindTexture(command.ResourceId, command.DirectoryPath);
				textures.Add(new Lifetime
				{
					Duration = command.DurationTicks
				});
				break;
			case 0:
				fades.Add(new ColorLerp
				{
					From = fadeColor,
					To = Rgba(command.PackedColorRgba),
					Duration = command.DurationTicks
				});
				break;
			}
		}

		private static Color32 Rgba(uint packed)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			return new Color32((byte)(packed & 0xFF), (byte)((packed >> 8) & 0xFF), (byte)((packed >> 16) & 0xFF), (byte)((packed >> 24) & 0xFF));
		}

		private static Color32 Argb(uint packed)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			return new Color32((byte)((packed >> 16) & 0xFF), (byte)((packed >> 8) & 0xFF), (byte)(packed & 0xFF), (byte)((packed >> 24) & 0xFF));
		}

		private static Texture2D FindTexture(string id, string directory)
		{
			id = (id ?? string.Empty).TrimEnd('\0', ' ');
			if (id.Length == 0 || (Object)(object)AVVfx.Asset == (Object)null)
			{
				return null;
			}
			Texture2D val = null;
			XiTextureBinding[] array = AVVfx.Asset.Textures;
			foreach (XiTextureBinding val2 in array)
			{
				if (!((Object)(object)val2?.texture == (Object)null) && !(val2.sectionId.TrimEnd('\0', ' ') != id))
				{
					if (!string.IsNullOrEmpty(directory) && directory.StartsWith(val2.directoryPath ?? "", StringComparison.OrdinalIgnoreCase))
					{
						return val2.texture;
					}
					val = val ?? val2.texture;
				}
			}
			return val;
		}

		internal void StepFfxiFrame()
		{
			//IL_0082: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			foreach (Lifetime texture in textures)
			{
				texture.Elapsed++;
			}
			textures.RemoveAll((Lifetime item) => item.Elapsed >= item.Duration);
			if (textures.Count == 0)
			{
				wrapTexture = null;
			}
			wrapColor = Advance(wrapColors, wrapColor);
			fadeColor = Advance(fades, fadeColor);
			foreach (UvLerp wrapUv in wrapUvs)
			{
				wrapUv.Elapsed = Mathf.Min(wrapUv.Elapsed + 1, wrapUv.Duration);
				float num = ((wrapUv.Duration == 0) ? 1f : ((float)wrapUv.Elapsed / (float)wrapUv.Duration));
				float num2 = Mathf.Lerp(wrapUv.From, wrapUv.To, num);
				this.wrapUv = ((wrapUv.Axis == 0) ? new Vector2(num2, this.wrapUv.y) : new Vector2(this.wrapUv.x, num2));
			}
			wrapUvs.RemoveAll((UvLerp item) => item.Elapsed >= item.Duration);
		}

		private static Color32 Advance(List<ColorLerp> items, Color32 current)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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)
			foreach (ColorLerp item in items)
			{
				item.Elapsed = Mathf.Min(item.Elapsed + 1, item.Duration);
				float t = ((item.Duration == 0) ? 1f : ((float)item.Elapsed / (float)item.Duration));
				current = new Color32(Lerp(item.From.r, item.To.r, t), Lerp(item.From.g, item.To.g, t), Lerp(item.From.b, item.To.b, t), Lerp(item.From.a, item.To.a, t));
			}
			items.RemoveAll((ColorLerp item) => item.Elapsed >= item.Duration);
			return current;
		}

		private static byte Lerp(byte a, byte b, float t)
		{
			return (byte)Mathf.FloorToInt((1f - t) * (float)(int)a + t * (float)(int)b);
		}

		internal void Render()
		{
			//IL_0057: 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_0091: 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_0186: Unknown result type (might be due to invalid IL or missing references)
			bool flag = Object.op_Implicit((Object)(object)wrapMaterial) && wrapColor.a > 0 && (wrapColor.r | wrapColor.g | wrapColor.b) != 0;
			if (flag)
			{
				wrapMaterial.SetColor("_XiFfxiWrapColor", Color32.op_Implicit(wrapColor));
				wrapMaterial.SetVector("_XiFfxiWrapOffset", new Vector4(wrapUv.x, wrapUv.y, 0f, 0f));
				wrapMaterial.SetFloat("_UseTexture", Object.op_Implicit((Object)(object)wrapTexture) ? 1f : 0f);
				if (Object.op_Implicit((Object)(object)wrapTexture))
				{
					wrapMaterial.SetTexture("_XiFfxiWrapTexture", (Texture)(object)wrapTexture);
				}
			}
			foreach (SkinnedMeshRenderer wrapRenderer in wrapRenderers)
			{
				if (Object.op_Implicit((Object)(object)wrapRenderer))
				{
					((Renderer)wrapRenderer).enabled = flag;
				}
			}
			bool flag2 = Object.op_Implicit((Object)(object)fadeMaterial) && (fadeColor.r != 128 || fadeColor.g != 128 || fadeColor.b != 128);
			if (flag2)
			{
				fadeMaterial.SetColor("_FadeColor", Color32.op_Implicit(fadeColor));
			}
			foreach (SkinnedMeshRenderer fadeRenderer in fadeRenderers)
			{
				if (Object.op_Implicit((Object)(object)fadeRenderer))
				{
					((Renderer)fadeRenderer).enabled = flag2;
				}
			}
		}

		public void Dispose()
		{
			foreach (SkinnedMeshRenderer wrapRenderer in wrapRenderers)
			{
				if (Object.op_Implicit((Object)(object)wrapRenderer))
				{
					Object.Destroy((Object)(object)((Component)wrapRenderer).gameObject);
				}
			}
			foreach (SkinnedMeshRenderer fadeRenderer in fadeRenderers)
			{
				if (Object.op_Implicit((Object)(object)fadeRenderer))
				{
					Object.Destroy((Object)(object)((Component)fadeRenderer).gameObject);
				}
			}
			if (Object.op_Implicit((Object)(object)wrapMaterial))
			{
				Object.Destroy((Object)(object)wrapMaterial);
			}
			if (Object.op_Implicit((Object)(object)fadeMaterial))
			{
				Object.Destroy((Object)(object)fadeMaterial);
			}
		}
	}
	internal sealed class AVTargetProxy : MonoBehaviour
	{
		internal Object Owner;

		private CharacterBody body;

		private bool ownerAssigned;

		internal XiPracticalActor Actor { get; private set; }

		internal static AVTargetProxy Create(AVTarget target)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0097: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00ca: Expected O, but got Unknown
			GameObject val = new GameObject("AV FFXI target");
			AVTargetProxy aVTargetProxy = val.AddComponent<AVTargetProxy>();
			aVTargetProxy.body = target.Body;
			float num = 2f;
			if (Object.op_Implicit((Object)(object)target.Body))
			{
				num = Mathf.Max(1f, (target.Body.corePosition.y - target.Body.footPosition.y) * 2f);
				val.transform.position = target.Body.footPosition;
				val.transform.rotation = Facing(target.Body);
			}
			else
			{
				val.transform.position = target.Point;
			}
			aVTargetProxy.Actor = new XiPracticalActor
			{
				Root = val.transform,
				Joints = XiPracticalSkeleton.BuildGenericAnchors(val.transform, num)
			};
			return aVTargetProxy;
		}

		private static Quaternion Facing(CharacterBody body)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0058: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			Transform val = (Object.op_Implicit((Object)(object)body.modelLocator) ? body.modelLocator.modelBaseTransform : null);
			Vector3 val2 = (Object.op_Implicit((Object)(object)val) ? val.forward : body.transform.forward);
			val2.y = 0f;
			if (!(((Vector3)(ref val2)).sqrMagnitude > 0f))
			{
				return Quaternion.identity;
			}
			return Quaternion.LookRotation(val2);
		}

		private void Update()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (Owner != (Object)null)
			{
				ownerAssigned = true;
			}
			else if (ownerAssigned)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			if (Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)body.healthComponent) && body.healthComponent.alive)
			{
				((Component)this).transform.position = body.footPosition;
				((Component)this).transform.rotation = Facing(body);
			}
		}
	}
	internal struct AVTarget
	{
		public CharacterBody Body;

		public Vector3 Point;

		public Vector3 CorePosition
		{
			get
			{
				//IL_0024: 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)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)Body))
				{
					return Point + Vector3.up;
				}
				return Body.corePosition;
			}
		}

		public static AVTarget Of(CharacterBody body)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			return new AVTarget
			{
				Body = body,
				Point = (Object.op_Implicit((Object)(object)body) ? body.footPosition : Vector3.zero)
			};
		}

		public static AVTarget At(Vector3 point)
		{
			//IL_000a: 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)
			return new AVTarget
			{
				Point = point
			};
		}
	}
	internal static class AVVfx
	{
		internal const string AV = "tens/tens";

		internal const string AVMotion = "tens/mot_";

		internal const string Aeroga = "airo";

		internal const string Tornado = "toln";

		internal const string Comet = "mete";

		internal const string Benediction = "kami";

		internal const string BloodWeapon = "blad";

		internal const string Chainspell = "renz";

		internal const string HundredFists = "hyak";

		internal const string MightyStrikes = "mats";

		internal const string PerfectDodge = "touz";

		internal const int TornadoExtraFrames = 120;

		private static float lastShake;

		internal static XiEffectAsset Asset { get; private set; }

		internal static XiSkeletonData Skeleton { get; private set; }

		internal static Material WrapOverlayMaterial { get; private set; }

		internal static Material FadeOverlayMaterial { get; private set; }

		internal static bool Ready => (Object)(object)Asset != (Object)null;

		internal static void Init(AssetBundle bundle)
		{
			Asset = bundle.LoadAllAssets<XiEffectAsset>().FirstOrDefault();
			Shader[] array = bundle.LoadAllAssets<Shader>();
			Shader[] array2 = array;
			foreach (Shader val in array2)
			{
				if (Object.op_Implicit((Object)(object)val))
				{
					XiParticleRenderer.RegisteredShaders[((Object)val).name] = val;
				}
			}
			WrapOverlayMaterial = MakeMaterial(array, "AV/FFXI Wrap Overlay");
			FadeOverlayMaterial = MakeMaterial(array, "AV/FFXI Fade Overlay");
			if ((Object)(object)Asset == (Object)null)
			{
				Log.Error("avvfx bundle does not contain the AVEffects XiEffectAsset.");
				return;
			}
			Skeleton = ((IEnumerable<XiSkeletonBinding>)Asset.Skeletons).FirstOrDefault((Func<XiSkeletonBinding, bool>)((XiSkeletonBinding s) => s.sectionId.TrimEnd('\0', ' ') == "ange"))?.skeleton;
			StretchTornado();
			XiPracticalEffect.CameraProvider = SceneCameras;
			Log.Info($"FFXI effects ready: {Asset.EffectRoutines.Length} routines, {Asset.ParticleGenerators.Length} generators, " + string.Format("{0} shaders, skeleton {1}", array.Length, (Skeleton != null) ? "ange" : "missing"));
		}

		private static void StretchTornado()
		{
			HashSet<string> hashSet = new HashSet<string> { "tb00", "tb01", "vib0", "wne0", "wne1", "ras0", "ras1" };
			int num = 0;
			XiParticleGeneratorBinding[] particleGenerators = Asset.ParticleGenerators;
			foreach (XiParticleGeneratorBinding val in particleGenerators)
			{
				if (!(val.directoryPath != "toln") && hashSet.Contains(val.sectionId.TrimEnd('\0', ' ')))
				{
					XiParticleGeneratorProgram program = val.program;
					XiParticleInstruction val2 = ((program != null && program.Sections?.Length > 1) ? ((IEnumerable<XiParticleInstruction>)val.program.Sections[1].Instructions).FirstOrDefault((Func<XiParticleInstruction, bool>)((XiParticleInstruction val5) => val5.OpCode == 1)) : null);
					if (val2?.RawOperands != null && val2.RawOperands.Length >= 8)
					{
						uint num2 = val2.RawOperands[7] >> 16;
						val2.RawOperands[7] = (num2 + 120 << 16) | (val2.RawOperands[7] & 0xFFFF);
						num++;
					}
				}
			}
			bool flag = false;
			XiEffectRoutineBinding val3 = ((IEnumerable<XiEffectRoutineBinding>)Asset.EffectRoutines).FirstOrDefault((Func<XiEffectRoutineBinding, bool>)((XiEffectRoutineBinding r) => r.directoryPath == "toln" && r.sectionId.TrimEnd('\0', ' ') == "main"));
			if (val3?.program?.Sections != null)
			{
				int num3 = 0;
				XiRoutineProgramSection[] sections = val3.program.Sections;
				for (int i = 0; i < sections.Length; i++)
				{
					XiRoutineInstruction[] instructions = sections[i].Instructions;
					foreach (XiRoutineInstruction val4 in instructions)
					{
						if (!flag && num3 >= 60 && val4.Delay > 0)
						{
							val4.Delay += 120;
							flag = true;
						}
						num3 += val4.Delay;
					}
				}
			}
			Log.Info($"Tornado II lengthened: {num} funnel particles +{120} frames, closing shifted: {flag}");
		}

		private static Material MakeMaterial(Shader[] shaders, string name)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			Shader val = ((IEnumerable<Shader>)shaders).FirstOrDefault((Func<Shader, bool>)((Shader s) => ((Object)s).name == name)) ?? Shader.Find(name);
			if ((Object)(object)val == (Object)null)
			{
				Log.Error("Missing shader " + name);
				return null;
			}
			return new Material(val)
			{
				name = name
			};
		}

		private static IEnumerable<Camera> SceneCameras()
		{
			foreach (CameraRigController readOnlyInstances in CameraRigController.readOnlyInstancesList)
			{
				if ((Object)(object)readOnlyInstances != (Object)null && (Object)(object)readOnlyInstances.sceneCam != (Object)null && ((Behaviour)readOnlyInstances.sceneCam).isActiveAndEnabled)
				{
					yield return readOnlyInstances.sceneCam;
				}
			}
		}

		internal static XiPracticalEffect Play(CharacterBody source, string routine, string directory, IList<AVTarget> targets = null, Action<int> onHit = null, float scaleMultiplier = 1f, float timeScale = 1f, bool detachedSounds = false)
		{
			if (!Ready || (Object)(object)source == (Object)null)
			{
				return null;
			}
			AVVfxActor aVVfxActor = AVVfxActor.Get(source);
			if ((Object)(object)aVVfxActor == (Object)null || !aVVfxActor.EnsureActor())
			{
				return null;
			}
			List<XiPracticalActor> list = new List<XiPracticalActor>();
			List<AVTargetProxy> list2 = new List<AVTargetProxy>();
			if (targets != null)
			{
				foreach (AVTarget target in targets)
				{
					AVTargetProxy aVTargetProxy = AVTargetProxy.Create(target);
					list2.Add(aVTargetProxy);
					list.Add(aVTargetProxy.Actor);
				}
			}
			if (list.Count == 0)
			{
				list.Add(aVVfxActor.Actor);
			}
			XiPracticalEffect val;
			try
			{
				val = XiPracticalEffect.Play(Asset, routine, directory, AVConfig.EffectScale.Value * scaleMultiplier, aVVfxActor.Actor, (IList<XiPracticalActor>)list, (IXiFfxiActorCommandContext)(object)aVVfxActor, 0u);
			}
			catch (Exception arg)
			{
				Log.Error($"FFXI routine {routine}@{directory} failed: {arg}");
				val = null;
			}
			if ((Object)(object)val == (Object)null)
			{
				foreach (AVTargetProxy item in list2)
				{
					Object.Destroy((Object)(object)((Component)item).gameObject);
				}
				return null;
			}
			foreach (AVTargetProxy item2 in list2)
			{
				item2.Owner = (Object)(object)val;
			}
			GameObject soundEmitter = ((Component)source).gameObject;
			List<uint> playing = new List<uint>();
			val.SoundEmitted = delegate(int id, Vector3 position)
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				if (detachedSounds)
				{
					uint num = AVSound.PlayAt(id, position, null);
					Log.Info($"{routine}: sound {id} -> playing id {num}");
				}
				else
				{
					uint num2 = AVSound.PlayAt(id, position, Object.op_Implicit((Object)(object)soundEmitter) ? soundEmitter.transform : null);
					if (num2 != 0)
					{
						playing.Add(num2);
					}
				}
			};
			val.CameraShake = delegate(Vector3 position, float near, float far, float amount)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				Shake(position, far, amount);
			};
			if (onHit != null)
			{
				val.Hit = onHit;
			}
			val.TimeScale = timeScale;
			aVVfxActor.Track(val, playing);
			return val;
		}

		private static void Shake(Vector3 position, float radius, float amount)
		{
			//IL_0029: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			if (AVConfig.CameraShake.Value && !(Time.time - lastShake < 0.1f))
			{
				lastShake = Time.time;
				ShakeEmitter.CreateSimpleShakeEmitter(position, new Wave
				{
					amplitude = Mathf.Clamp(amount, 0f, 0.33f) * 6f,
					frequency = 30f,
					cycleOffset = 0f
				}, 0.15f, Mathf.Max(radius, 30f), true);
			}
		}
	}
	internal sealed class AVVfxActor : MonoBehaviour, IXiFfxiActorCommandContext, IXiFfxiActorCommandBackend
	{
		private CharacterBody body;

		private Animator animator;

		private AVAnimationDriver driver;

		private Transform visual;

		private string pendingFollowUp;

		private float followUpAt;

		private bool? pendingWeaponVisibility;

		private readonly List<(XiPracticalEffect effect, List<uint> sounds)> effects = new List<(XiPracticalEffect, List<uint>)>();

		private readonly AVActorLook look = new AVActorLook();

		private float lookClock;

		private float weaponDeadline;

		private CharacterModel characterModel;

		internal XiPracticalActor Actor { get; private set; }

		internal Renderer Spear { get; private set; }

		internal static AVVfxActor Get(CharacterBody body)
		{
			if (!Object.op_Implicit((Object)(object)body))
			{
				return null;
			}
			AVVfxActor component = ((Component)body).GetComponent<AVVfxActor>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return ((Component)body).gameObject.AddComponent<AVVfxActor>();
			}
			return component;
		}

		internal bool EnsureActor()
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			if (Actor != null && Object.op_Implicit((Object)(object)Actor.Root))
			{
				return true;
			}
			body = ((Component)this).GetComponent<CharacterBody>();
			ModelLocator val = (Object.op_Implicit((Object)(object)body) ? body.modelLocator : null);
			if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val.modelBaseTransform) || !Object.op_Implicit((Object)(object)val.modelTransform) || AVVfx.Skeleton == null)
			{
				return false;
			}
			visual = val.modelTransform.Find("AbsoluteVirtueVisual");
			if (!Object.op_Implicit((Object)(object)visual))
			{
				return false;
			}
			animator = ((Component)visual).GetComponentInChildren<Animator>(true);
			driver = ((Component)this).GetComponent<AVAnimationDriver>();
			Renderer[] componentsInChildren = ((Component)visual).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val2 in componentsInChildren)
			{
				if (((Object)val2).name.EndsWith("wep3"))
				{
					Spear = val2;
				}
			}
			Actor = new XiPracticalActor
			{
				Root = val.modelBaseTransform,
				Joints = XiPracticalSkeleton.BuildAnchors(visual, AVVfx.Skeleton, new Vector3(1f, -1f, 1f), "bone")
			};
			look.Attach(visual);
			return true;
		}

		internal void Track(XiPracticalEffect effect, List<uint> sounds)
		{
			effects.Add((effect, sounds));
		}

		internal static void Stop(XiPracticalEffect effect)
		{
			if (!Object.op_Implicit((Object)(object)effect))
			{
				return;
			}
			AVVfxActor aVVfxActor = ((Object.op_Implicit((Object)(object)effect.Context) && Object.op_Implicit((Object)(object)effect.Context.SourceActorRoot)) ? ((Component)effect.Context.SourceActorRoot).GetComponentInParent<AVVfxActor>() : null);
			if (Object.op_Implicit((Object)(object)aVVfxActor))
			{
				foreach (var effect2 in aVVfxActor.effects)
				{
					if (!((Object)(object)effect2.effect == (Object)(object)effect))
					{
						continue;
					}
					foreach (uint item in effect2.sounds)
					{
						AVSound.Stop(item);
					}
				}
			}
			effect.Finish();
		}

		internal void SetWeaponVisibleOnNextCommand(bool visible)
		{
			pendingWeaponVisibility = visible;
			weaponDeadline = Time.time + 1.2f;
		}

		internal void SetWeaponVisible(bool visible)
		{
			EnsureActor();
			if (Object.op_Implicit((Object)(object)Spear))
			{
				Spear.enabled = visible;
			}
		}

		private void HideSpearWithBody()
		{
			if (Object.op_Implicit((Object)(object)Spear) && Object.op_Implicit((Object)(object)body))
			{
				if (!Object.op_Implicit((Object)(object)characterModel) && Object.op_Implicit((Object)(object)body.modelLocator) && Object.op_Implicit((Object)(object)body.modelLocator.modelTransform))
				{
					characterModel = ((Component)body.modelLocator.modelTransform).GetComponent<CharacterModel>();
				}
				Spear.forceRenderingOff = (Object)(object)body.currentVehicle != (Object)null || (Object.op_Implicit((Object)(object)characterModel) && characterModel.invisibilityCount > 0);
			}
		}

		private void Update()
		{
			effects.RemoveAll(((XiPracticalEffect effect, List<uint> sounds) item) => !Object.op_Implicit((Object)(object)item.effect));
			if (Object.op_Implicit((Object)(object)Spear) || EnsureActor())
			{
				HideSpearWithBody();
			}
			if (pendingWeaponVisibility.HasValue && Time.time >= weaponDeadline)
			{
				SetWeaponVisible(pendingWeaponVisibility.Value);
				pendingWeaponVisibility = null;
			}
			if (pendingFollowUp != null && Time.time >= followUpAt)
			{
				PlayState(pendingFollowUp, 0.4f);
				pendingFollowUp = null;
			}
			lookClock += Time.deltaTime;
			while (lookClock >= 1f / 60f)
			{
				lookClock -= 1f / 60f;
				look.StepFfxiFrame();
			}
			look.Render();
		}

		private void OnDestroy()
		{
			look.Dispose();
			foreach (var effect in effects)
			{
				if (Object.op_Implicit((Object)(object)effect.effect))
				{
					effect.effect.Finish();
				}
			}
		}

		public bool TryValidate(XiFfxiActorCommand command, out string reason)
		{
			reason = null;
			return true;
		}

		public bool TryExecute(XiFfxiActorCommand command, out string reason)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected I4, but got Unknown
			reason = null;
			if (command == null || command.UseTargetActor)
			{
				return true;
			}
			XiFfxiActorCommandKind kind = command.Kind;
			switch (kind - 1)
			{
			case 0:
				PlayMotion(command.ResourceId, command.DurationTicks);
				break;
			case 10:
				if (Object.op_Implicit((Object)(object)driver))
				{
					driver.ReleaseMotionLock();
				}
				break;
			case 4:
			case 5:
			case 6:
			case 7:
				look.Apply(command);
				break;
			case 11:
			case 12:
			case 13:
			case 15:
				if (pendingWeaponVisibility.HasValue)
				{
					SetWeaponVisible(pendingWeaponVisibility.Value);
					pendingWeaponVisibility = null;
				}
				break;
			}
			return true;
		}

		private void PlayMotion(string resourceId, int durationTicks)
		{
			string text = (resourceId ?? string.Empty).TrimEnd('\0', ' ').Replace('?', '0');
			if (!text.StartsWith("at"))
			{
				switch (text)
				{
				case "mw10":
				case "cm00":
					text = "wz60";
					break;
				case "mw20":
				case "cm10":
					text = "ta00";
					pendingFollowUp = "ta10";
					followUpAt = Time.time + Mathf.Max(0.3f, (float)durationTicks / 60f * 0.6f);
					break;
				}
				PlayState(text, Mathf.Max((float)durationTicks / 60f, 0.3f));
			}
		}

		internal void HoldState(string state)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (EnsureActor() && Object.op_Implicit((Object)(object)animator))
			{
				if (Object.op_Implicit((Object)(object)driver))
				{
					driver.LockFor(0.25f);
				}
				int num = Animator.StringToHash("Base Layer." + state);
				AnimatorStateInfo currentAnimatorStateInfo = animator.GetCurrentAnimatorStateInfo(0);
				if (((AnimatorStateInfo)(ref currentAnimatorStateInfo)).fullPathHash != num && !animator.IsInTransition(0) && animator.HasState(0, num))
				{
					animator.CrossFadeInFixedTime(num, 0.15f, 0);
				}
			}
		}

		internal void PlayState(string state, float lockSeconds)
		{
			if (!EnsureActor() || !Object.op_Implicit((Object)(object)animator))
			{
				return;
			}
			int num = Animator.StringToHash("Base Layer." + state);
			if (animator.HasState(0, num))
			{
				if (Object.op_Implicit((Object)(object)driver))
				{
					driver.LockFor(lockSeconds);
				}
				animator.CrossFadeInFixedTime(num, 0.12f, 0);
			}
		}
	}
}
namespace AbsoluteVirtueSurvivor.Sound
{
	internal static class AVSound
	{
		private static readonly HashSet<int> available = new HashSet<int>();

		private static string bankPath;

		internal static void Init(string pluginDirectory)
		{
			bankPath = Path.Combine(pluginDirectory, "AbsoluteVirtueBank.bnk");
			string path = Path.Combine(pluginDirectory, "bank-ids.txt");
			if (File.Exists(path))
			{
				string[] array = File.ReadAllLines(path);
				for (int i = 0; i < array.Length; i++)
				{
					if (int.TryParse(array[i].Trim(), out var result))
					{
						available.Add(result);
					}
				}
			}
			RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, new Action(LoadBank));
		}

		private static void LoadBank()
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			uint num = default(uint);
			AKRESULT val = AkSoundEngine.LoadBank(bankPath, ref num);
			if ((int)val == 1 || (int)val == 69)
			{
				Log.Info($"Loaded AbsoluteVirtueBank ({num}), {available.Count} FFXI sounds");
			}
			else
			{
				Log.Error($"Could not load {bankPath}: {val}");
			}
		}

		internal static bool Has(int soundId)
		{
			return available.Contains(soundId);
		}

		internal static uint Play(int soundId, GameObject emitter)
		{
			if ((Object)(object)emitter == (Object)null || !available.Contains(soundId))
			{
				return 0u;
			}
			return Util.PlaySound("Play_AV_" + soundId, emitter);
		}

		internal static uint PlayAt(int soundId, Vector3 position, Transform follow)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!available.Contains(soundId))
			{
				return 0u;
			}
			GameObject val = new GameObject("AV FFXI sound " + soundId);
			val.transform.position = position;
			if (Object.op_Implicit((Object)(object)follow))
			{
				val.transform.SetParent(follow, true);
			}
			AkGameObj obj = val.AddComponent<AkGameObj>();
			obj.isStaticObject = false;
			obj.isStaticAfterDelay = false;
			uint result = AkSoundEngine.PostEvent("Play_AV_" + soundId, val);
			Object.Destroy((Object)(object)val, 30f);
			return result;
		}

		internal static void Stop(uint playingId)
		{
			if (playingId != 0)
			{
				AkSoundEngine.StopPlayingID(playingId);
			}
		}
	}
}
namespace AbsoluteVirtueSurvivor.Skills
{
	internal static class AVSkills
	{
		internal static SkillDef Aeroga;

		internal static SkillDef Tornado;

		internal static SkillDef Comet;

		internal static SkillDef Benediction;

		internal static SkillDef BloodWeapon;

		internal static SkillDef PerfectDodge;

		internal static SkillDef Fervor;

		internal static bool Initialize(GameObject bodyPrefab)
		{
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			SkillLocator component = bodyPrefab.GetComponent<SkillLocator>();
			if (!Object.op_Implicit((Object)(object)component) || !Object.op_Implicit((Object)(object)component.secondary) || !Object.op_Implicit((Object)(object)component.utility) || !Object.op_Implicit((Object)(object)component.special))
			{
				return false;
			}
			Aeroga = Make("AerogaIV", typeof(AerogaIVState), AVConfig.AerogaCooldown.Value, 1, "Aeroga IV", "Channel for <style=cIsUtility>10s</style>, then strike every enemy around the target with <style=cIsDamage>4 waves of wind</style> for <style=cIsDamage>1400%</style> damage in total.");
			Tornado = Make("TornadoII", typeof(TornadoIIState), AVConfig.TornadoCooldown.Value, 1, "Tornado II", "Channel for <style=cIsUtility>10s</style>, then trap one enemy in a tornado that hits it <style=cIsDamage>12 times for 2400%</style> damage in total and <style=cIsUtility>lowers its armor by 25</style>.");
			Comet = Make("Comet", typeof(CometState), AVConfig.CometCooldown.Value, 1, "Comet", "Channel for <style=cIsUtility>10s</style>, then drop a comet for <style=cIsDamage>3500%</style> dark damage around the target. <style=cIsDamage>Each cast makes the next one 5% stronger</style> (up to +50%).");
			Benediction = Make("Benediction", typeof(BenedictionState), AVConfig.BenedictionCooldown.Value, 2, "Benediction", "<style=cIsHealing>Fully heal</style> and <style=cIsUtility>cleanse</style> yourself and every ally nearby. <style=cIsUtility>Instant, 2 charges.</style>");
			BloodWeapon = Make("BloodWeapon", typeof(BloodWeaponState), AVConfig.BloodWeaponCooldown.Value, 1, "Blood Weapon", "For <style=cIsUtility>30s</style>, polearm attacks <style=cIsHealing>heal you for the damage dealt</style>.");
			PerfectDodge = Make("PerfectDodge", typeof(PerfectDodgeState), AVConfig.PerfectDodgeCooldown.Value, 1, "Perfect Dodge", "For <style=cIsUtility>10s</style>, <style=cIsUtility>no attack can hit you</style>.");
			Fervor = Make("Fervor", typeof(FervorState), AVConfig.FervorCooldown.Value, 1, "Apotheosis", "<style=cIsUtility>(Chainspell + Hundred Fists + Mighty Strikes)</style> For <style=cIsUtility>45s</style>: <style=cIsUtility>spells are instant</style> and their <style=cIsUtility>recast is divided by 3</style>, <style=cIsDamage>+100% attack speed</style>, and <style=cIsDamage>every hit is critical</style>.");
			Assign(component.secondary, Aeroga, "Secondary");
			Assign(component.utility, Tornado, "Utility");
			Assign(component.special, Comet, "Special");
			Type[] array = new Type[7]
			{
				typeof(AerogaIVState),
				typeof(TornadoIIState),
				typeof(CometState),
				typeof(BenedictionState),
				typeof(BloodWeaponState),
				typeof(PerfectDodgeState),
				typeof(FervorState)
			};
			for (int i = 0; i < array.Length; i++)
			{
				AVContent.AddEntityState(array[i]);
			}
			component.passiveSkill = new PassiveSkill
			{
				enabled = true,
				skillNameToken = "ABSOLUTE_VIRTUE_PASSIVE_NAME",
				skillDescriptionToken = "ABSOLUTE_VIRTUE_PASSIVE_DESCRIPTION",
				icon = AVIcons.Get("Passive")
			};
			LanguageAPI.Add("ABSOLUTE_VIRTUE_PASSIVE_NAME", "Absolute Virtue");
			LanguageAPI.Add("ABSOLUTE_VIRTUE_PASSIVE_DESCRIPTION", "<style=cIsHealing>Auto Regen</style>: high natural regeneration. <style=cIsUtility>Magic Defense Bonus</style>: damage over time is halved. Press <style=cIsUtility>D-pad left</style> (or <style=cIsUtility>" + ((object)AVConfig.StanceKey.Value/*cast due to .constrained prefix*/).ToString() + "</style>) to switch between the <style=cIsDamage>Magic</style> and <style=cIsUtility>Ability</style> stances.");
			bodyPrefab.AddComponent<AVStanceController>();
			return true;
		}

		private static SkillDef Make(string id, Type state, float cooldown, int stock, string name, string description)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			SkillDef obj = ScriptableObject.CreateInstance<SkillDef>();
			((Object)obj).name = "AV" + id;
			obj.skillName = "AV" + id;
			obj.skillNameToken = "ABSOLUTE_VIRTUE_" + id.ToUpperInvariant() + "_NAME";
			obj.skillDescriptionToken = "ABSOLUTE_VIRTUE_" + id.ToUpperInvariant() + "_DESCRIPTION";
			obj.icon = AVIcons.Get(id);
			obj.activationState = new SerializableEntityStateType(state);
			obj.activationStateMachineName = "Weapon";
			obj.interruptPriority = (InterruptPriority)1;
			obj.baseRechargeInterval = cooldown;
			obj.baseMaxStock = stock;
			obj.rechargeStock = 1;
			obj.requiredStock = 1;
			obj.stockToConsume = 1;
			obj.fullRestockOnAssign = false;
			obj.beginSkillCooldownOnSkillEnd = false;
			obj.isCombatSkill = true;
			obj.mustKeyPress = true;
			obj.cancelSprintingOnActivation = true;
			obj.canceledFromSprinting = false;
			LanguageAPI.Add(obj.skillNameToken, name);
			LanguageAPI.Add(obj.skillDescriptionToken, description);
			AVContent.AddSkillDef(obj);
			return obj;
		}

		private static void Assign(GenericSkill slot, SkillDef skill, string slotName)
		{
			//IL_0027: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			SkillFamily val = ScriptableObject.CreateInstance<SkillFamily>();
			((Object)val).name = "AbsoluteVirtue" + slotName + "Family";
			Variant[] array = new Variant[1];
			Variant val2 = new Variant
			{
				skillDef = skill
			};
			((Variant)(ref val2)).viewableNode = new Node(skill.skillNameToken, false, (Node)null);
			array[0] = val2;
			val.variants = (Variant[])(object)array;
			slot._skillFamily = val;
			AVContent.AddSkillFamily(val);
		}
	}
	internal sealed class AVStanceController : MonoBehaviour
	{
		private struct SlotState
		{
			public int stock;

			public float stopwatch;

			public float savedAt;

			public bool initialized;
		}

		private CharacterBody body;

		private GenericSkill[] slots;

		private SkillDef[] magic;

		private SkillDef[] ability;

		private SlotState[] magicStates;

		private SlotState[] abilityStates;

		private bool abilityStance;

		private bool initialized;

		internal bool AbilityStance => abilityStance;

		private void Start()
		{
			body = ((Component)this).GetComponent<CharacterBody>();
			SkillLocator component = ((Component)this).GetComponent<SkillLocator>();
			if (!Object.op_Implicit((Object)(object)body) || !Object.op_Implicit((Object)(object)component))
			{
				((Behaviour)this).enabled = false;
				return;
			}
			slots = (GenericSkill[])(object)new GenericSkill[4] { component.primary, component.secondary, component.utility, component.special };
			magic = (SkillDef[])(object)new SkillDef[4]
			{
				(SkillDef)AVPolearmSkills.PrimarySkillDef,
				AVSkills.Aeroga,
				AVSkills.Tornado,
				AVSkills.Comet
			};
			ability = (SkillDef[])(object)new SkillDef[4]
			{
				AVSkills.Benediction,
				AVSkills.BloodWeapon,
				AVSkills.PerfectDodge,
				AVSkills.Fervor
			};
			magicStates = new SlotState[4];
			abilityStates = new SlotState[4];
			initialized = true;
		}

		private void Update()
		{
			if (initialized && Object.op_Implicit((Object)(object)body) && body.hasEffectiveAuthority && StancePressed())
			{
				Toggle();
			}
		}

		private static bool StancePressed()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut value = AVConfig.StanceKey.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				return true;
			}
			if (!ReInput.isReady)
			{
				return false;
			}
			Player player = ReInput.players.GetPlayer(0);
			if (player == null)
			{
				return false;
			}
			foreach (Joystick joystick in player.controllers.Joysticks)
			{
				IGamepadTemplate template = ((Controller)joystick).GetTemplate<IGamepadTemplate>();
				if (template != null && template.dPad.left.justPressed)
				{
					return true;
				}
			}
			return false;
		}

		internal void Toggle()
		{
			Save(abilityStance ? abilityStates : magicStates, abilityStance ? ability : magic);
			abilityStance = !abilityStance;
			SkillDef[] array = (abilityStance ? ability : magic);
			for (int i = 0; i < 4; i++)
			{
				slots[i].UnsetSkillOverride((object)this, magic[i], (SkillOverridePriority)4);
				slots[i].UnsetSkillOverride((object)this, ability[i], (SkillOverridePriority)4);
				if (abilityStance)
				{
					slots[i].SetSkillOverride((object)this, array[i], (SkillOverridePriority)4);
				}
			}
			Restore(abilityStance ? abilityStates : magicStates);
			AVVfxActor aVVfxActor = AVVfxActor.Get(body);
			if (Object.op_Implicit((Object)(object)aVVfxActor))
			{
				aVVfxActor.SetWeaponVisibleOnNextCommand(!abilityStance);
				if ((Object)(object)AVVfx.Play(body, abilityStance ? "bton" : "ntob", "tens/mot_") == (Object)null)
				{
					aVVfxActor.SetWeaponVisible(!abilityStance);
				}
			}
			Log.Info("Absolute Virtue stance: " + (abilityStance ? "Ability" : "Magic"));
		}

		private void Save(SlotState[] states, SkillDef[] defs)
		{
			for (int i = 0; i < 4; i++)
			{
				states[i].stock = slots[i].stock;
				states[i].stopwatch = slots[i].rechargeStopwatch;
				states[i].savedAt = Time.time;
				states[i].initialized = true;
			}
		}

		private void Restore(SlotState[] states)
		{
			for (int i = 0; i < 4; i++)
			{
				GenericSkill val = slots[i];
				if (!states[i].initialized)
				{
					states[i] = new SlotState
					{
						stock = val.maxStock,
						stopwatch = 0f,
						savedAt = Time.time,
						initialized = true
					};
				}
				val.stock = Mathf.Clamp(states[i].stock, 0, val.maxStock);
				val.rechargeStopwatch = Mathf.Max(0f, states[i].stopwatch + (Time.time - states[i].savedAt));
			}
		}

		private void OnDestroy()
		{
			if (!initialized)
			{
				return;
			}
			for (int i = 0; i < 4; i++)
			{
				if (Object.op_Implicit((Object)(object)slots[i]))
				{
					slots[i].UnsetSkillOverride((object)this, ability[i], (SkillOverridePriority)4);
				}
			}
		}
	}
}
namespace AbsoluteVirtueSurvivor.Skills.Polearm
{
	internal static class AVPolearmSkills
	{
		internal static SteppedSkillDef PrimarySkillDef { get; private set; }

		internal static bool Initialize(GameObject bodyPrefab)
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: 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_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Expected O, but got Unknown
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)bodyPrefab == (Object)null)
			{
				Debug.LogError((object)"[AbsoluteVirtue] Cannot create polearm skill: body prefab is null.");
				return false;
			}
			SkillLocator component = bodyPrefab.GetComponent<SkillLocator>();
			if ((Object)(object)component == (Object)null || (Object)(object)component.primary == (Object)null)
			{
				Debug.LogError((object)"[AbsoluteVirtue] Body has no primary GenericSkill.");
				return false;
			}
			SkillFamily val = ScriptableObject.CreateInstance<SkillFamily>();
			((Object)val).name = "AbsoluteVirtuePrimaryFamily";
			val.variants = Array.Empty<Variant>();
			Sprite val2 = null;
			SkillFamily skillFamily = component.primary.skillFamily;
			if ((Object)(object)skillFamily != (Object)null && skillFamily.variants != null && skillFamily.variants.Length != 0)
			{
				val2 = skillFamily.variants[0].skillDef?.icon;
			}
			PrimarySkillDef = ScriptableObject.CreateInstance<SteppedSkillDef>();
			((Object)PrimarySkillDef).name = "AbsoluteVirtuePolearmCombo";
			((SkillDef)PrimarySkillDef).skillName = "AbsoluteVirtuePolearmCombo";
			((SkillDef)PrimarySkillDef).skillNameToken = "ABSOLUTE_VIRTUE_PRIMARY_POLEARM_NAME";
			((SkillDef)PrimarySkillDef).skillDescriptionToken = "ABSOLUTE_VIRTUE_PRIMARY_POLEARM_DESCRIPTION";
			((SkillDef)PrimarySkillDef).icon = AVIcons.Get("Polearm") ?? val2;
			((SkillDef)PrimarySkillDef).activationState = new SerializableEntityStateType(typeof(AVPolearmComboState));
			((SkillDef)PrimarySkillDef).activationStateMachineName = "Weapon";
			((SkillDef)PrimarySkillDef).interruptPriority = (InterruptPriority)1;
			((SkillDef)PrimarySkillDef).baseMaxStock = 1;
			((SkillDef)PrimarySkillDef).baseRechargeInterval = 0f;
			((SkillDef)PrimarySkillDef).rechargeStock = 1;
			((SkillDef)PrimarySkillDef).requiredStock = 1;
			((SkillDef)PrimarySkillDef).stockToConsume = 1;
			((SkillDef)PrimarySkillDef).fullRestockOnAssign = true;
			((SkillDef)PrimarySkillDef).dontAllowPastMaxStocks = false;
			((SkillDef)PrimarySkillDef).beginSkillCooldownOnSkillEnd = false;
			((SkillDef)PrimarySkillDef).resetCooldownTimerOnUse = false;
			((SkillDef)PrimarySkillDef).isCombatSkill = true;
			((SkillDef)PrimarySkillDef).mustKeyPress = false;
			((SkillDef)PrimarySkillDef).cancelSprintingOnActivation = true;
			((SkillDef)PrimarySkillDef).canceledFromSprinting = false;
			((SkillDef)PrimarySkillDef).forceSprintDuringState = false;
			PrimarySkillDef.stepCount = 3;
			PrimarySkillDef.stepGraceDuration = 0.8f;
			Variant[] array = new Variant[1];
			Variant val3 = new Variant
			{
				skillDef = (SkillDef)(object)PrimarySkillDef,
				unlockableDef = null
			};
			((Variant)(ref val3)).viewableNode = new Node(((SkillDef)PrimarySkillDef).skillNameToken, false, (Node)null);
			array[0] = val3;
			val.variants = (Variant[])(object)array;
			component.primary._skillFamily = val;
			AVContent.AddSkillDef((SkillDef)(object)PrimarySkillDef);
			AVContent.AddSkillFamily(val);
			AVContent.AddEntityState(typeof(AVPolearmComboState));
			LanguageAPI.Add("ABSOLUTE_VIRTUE_PRIMARY_POLEARM_NAME", "Polearm Combo");
			LanguageAPI.Add("ABSOLUTE_VIRTUE_PRIMARY_POLEARM_DESCRIPTION", "Strike for <style=cIsDamage>400%</style>, then <style=cIsDamage>450%</style>, then <style=cIsDamage>500%</style> damage. A critical strike becomes a sweeping blow for <style=cIsDamage>700%</style>. <style=cIsUtility>Hold to keep the combo going.</style>");
			Debug.Log((object)"[AbsoluteVirtue] Polearm Combo primary registered.");
			return true;
		}
	}
}
namespace AbsoluteVirtueSurvivor.Skills.Magic
{
	public abstract class AVSpellState : BaseSkillState
	{
		private GameObject targetObject;

		private Vector3 targetPoint;

		private float castTime;

		private bool released;

		private XiPracticalEffect castEffect;

		private float releaseAge;

		private int hitsApplied;

		private bool damageDone;

		private float damagePerHit;

		private bool crit;

		protected abstract string Directory { get; }

		protected abstract float DamageCoefficient { get; }

		protected abstract float BlastRadius { get; }

		protected virtual int DamageHits => 1;

		protected virtual float ProcCoefficient => 1f;

		protected virtual float AfterReleaseDuration => 1.2f;

		protected virtual bool AreaTargets => false;

		protected virtual DamageSource Source => (DamageSource)2;

		protected virtual int[] PulseFrames => null;

		protected virtual bool UsesHitMarkers => true;

		protected virtual float EffectScaleMultiplier => 1f;

		protected virtual float EffectTimeScale => 1f;

		protected virtual void OnSpellHit(CharacterBody target)
		{
		}

		public override void OnEnter()
		{
			((BaseState)this).OnEnter();
			bool flag = Object.op_Implicit((Object)(object)((EntityState)this).characterBody) && ((EntityState)this).characterBody.HasBuff(AVBuffs.Fervor);
			castTime = (flag ? 0f : AVConfig.CastTime);
			if (((EntityState)this).isAuthority)
			{
				PickTarget();
			}
			((BaseState)this).StartAimMode(castTime + 1f, false);
			if (castTime > 0f)
			{
				castEffect = AVVfx.Play(((EntityState)this).characterBody, "cabk", "tens/tens");
			}
		}

		private void PickTarget()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//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_0032: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//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_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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			Ray aimRay = ((BaseState)this).GetAimRay();
			BullseyeSearch val = new BullseyeSearch
			{
				viewer = ((EntityState)this).characterBody,
				searchOrigin = ((Ray)(ref aimRay)).origin,
				searchDirection = ((Ray)(ref aimRay)).direction,
				maxAngleFilter = 25f,
				maxDistanceFilter = 150f,
				teamMaskFilter = TeamMask.GetUnprotectedTeams(((BaseState)this).GetTeam()),
				filterByLoS = true,
				sortMode = (SortMode)2
			};
			val.RefreshCandidates();
			val.FilterOutGameObject(((EntityState)this).gameObject);
			HurtBox val2 = val.GetResults().FirstOrDefault();
			CharacterBody val3 = ((Object.op_Implicit((Object)(object)val2) && Object.op_Implicit((Object)(object)val2.healthComponent)) ? val2.healthComponent.body : null);
			if (Object.op_Implicit((Object)(object)val3))
			{
				targetObject = ((Component)val3).gameObject;
				targetPoint = val3.footPosition;
			}
			else
			{
				RaycastHit val4 = default(RaycastHit);
				targetPoint = (Physics.Raycast(aimRay, ref val4, 150f, LayerMask.op_Implicit(((LayerIndex)(ref LayerIndex.world)).mask), (QueryTriggerInteraction)1) ? ((RaycastHit)(ref val4)).point : ((Ray)(ref aimRay)).GetPoint(40f));
			}
		}

		public override void FixedUpdate()
		{
			((EntityState)this).FixedUpdate();
			if (!released && ((EntityState)this).fixedAge >= castTime)
			{
				Release();
			}
			if (!released)
			{
				if (((EntityState)this).fixedAge > 0.3f)
				{
					AVVfxActor.Get(((EntityState)this).characterBody)?.HoldState("ma00");
				}
				return;
			}
			releaseAge += Time.fixedDeltaTime;
			if (((EntityState)this).isAuthority && releaseAge >= AfterReleaseDuration)
			{
				((EntityState)this).outer.SetNextStateToMain();
			}
		}

		private void Release()
		{
			released = true;
			AVVfxActor.Stop(castEffect);
			castEffect = null;
			crit = ((BaseState)this).RollCrit();
			damagePerHit = ((BaseState)this).damageStat * DamageCoefficient * AVBuffs.CometMultiplier((Directory == "mete") ? ((EntityState)this).characterBody : null) / (float)Mathf.Max(1, DamageHits);
			List<AVTarget> targets = BuildTargets();
			AVVfx.Play(((EntityState)this).characterBody, "shbk", "tens/tens");
			XiPracticalEffect val = AVVfx.Play(((EntityState)this).characterBody, "main", Directory, targets, OnHitMarker, EffectScaleMultiplier, EffectTimeScale);
			int[] pulses = PulseFrames;
			if ((Object)(object)val != (Object)null && pulses != null && ((EntityState)this).isAuthority)
			{
				int nextPulse = 0;
				val.Stepped = delegate(long frame)
				{
					while (nextPulse < pulses.Length && frame >= pulses[nextPulse])
					{
						nextPulse++;
						RegisterHit();
					}
				};
			}
			if (((EntityState)this).isAuthority)
			{
				if ((Object)(object)val == (Object)null)
				{
					ApplyRemainingDamage();
				}
				else
				{
					val.Ended = (Action)Delegate.Combine(val.Ended, (Action)delegate
					{
						if (!damageDone)
						{
							ApplyRemainingDamage();
						}
					});
				}
			}
			OnReleased();
			if (((EntityState)this).isAuthority && ((EntityState)this).characterBody.HasBuff(AVBuffs.Fervor) && Object.op_Implicit((Object)(object)((BaseSkillState)this).activatorSkillSlot))
			{
				float num = Mathf.Max(1f, AVConfig.ApotheosisCooldownDivisor.Value);
				((BaseSkillState)this).activatorSkillSlot.rechargeStopwatch = Mathf.Max(((BaseSkillState)this).activatorSkillSlot.rechargeStopwatch, ((BaseSkillState)this).activatorSkillSlot.finalRechargeInterval * (1f - 1f / num));
			}
		}

		protected virtual void OnReleased()
		{
		}

		private List<AVTarget> BuildTargets()
		{
			//IL_002b: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody val = (Object.op_Implicit((Object)(object)targetObject) ? targetObject.GetComponent<CharacterBody>() : null);
			List<AVTarget> list = new List<AVTarget> { Object.op_Implicit((Object)(object)val) ? AVTarget.Of(val) : AVTarget.At(targetPoint) };
			if (!AreaTargets)
			{
				return list;
			}
			Vector3 corePosition = list[0].CorePosition;
			TeamIndex team = ((BaseState)this).GetTeam();
			foreach (CharacterBody readOnlyInstances in CharacterBody.readOnlyInstancesList)
			{
				if (list.Count >= 8)
				{
					break;
				}
				if (Object.op_Implicit((Object)(object)readOnlyInstances) && !((Object)(object)readOnlyInstances == (Object)(object)val) && !((Object)(object)readOnlyInstances == (Object)(object)((EntityState)this).characterBody) && Object.op_Implicit((Object)(object)readOnlyInstances.healthComponent) && readOnlyInstances.healthComponent.alive && Object.op_Implicit((Object)(object)readOnlyInstances.teamComponent) && readOnlyInstances.teamComponent.teamIndex != team)
				{
					Vector3 val2 = readOnlyInstances.corePosition - corePosition;
					if (!(((Vector3)(ref val2)).sqrMagnitude > BlastRadius * BlastRadius))
					{
						list.Add(AVTarget.Of(readOnlyInstances));
					}
				}
			}
			return list;
		}

		private void OnHitMarker(int targetIndex)
		{
			if (((EntityState)this).isAuthority && !damageDone && UsesHitMarkers && targetIndex <= 0)
			{
				RegisterHit();
			}
		}

		private void RegisterHit()
		{
			if (!damageDone)
			{
				hitsApplied++;
				Blast(damagePerHit);
				if (hitsApplied >= Mathf.Max(1, DamageHits))
				{
					damageDone = true;
				}
			}
		}

		private void ApplyRemainingDamage()
		{
			int num = Mathf.Max(1, DamageHits) - hitsApplied;
			if (num > 0)
			{
				Blast(damagePerHit * (float)num);
			}
			hitsApplied = Mathf.Max(1, DamageHits);
			damageDone = true;
		}

		private void Blast(float damage)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0042: 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)
			//IL_005a: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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_007b: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_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_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)
			//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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody val = (Object.op_Implicit((Object)(object)targetObject) ? targetObject.GetComponent<CharacterBody>() : null);
			Vector3 position = (Object.op_Implicit((Object)(object)val) ? val.corePosition : (targetPoint + Vector3.up));
			HitPoint[] array = (HitPoint[])(((object)new BlastAttack
			{
				attacker = ((EntityState)this).gameObject,
				inflictor = ((EntityState)this).gameObject,
				teamIndex = ((BaseState)this).GetTeam(),
				position = position,
				radius = BlastRadius,
				falloffModel = (FalloffModel)0,
				baseDamage = damage,
				baseForce = 0f,
				crit = crit,
				damageType = new DamageTypeCombo(DamageTypeCombo.op_Implicit((DamageType)0), (DamageTypeExtended)0, Source),
				procCoefficient = ProcCoefficient,
				attackerFiltering = (AttackerFiltering)2
			}.Fire().hitPoints) ?? ((object)new HitPoint[0]));
			foreach (HitPoint val2 in array)
			{
				CharacterBody val3 = ((Object.op_Implicit((Object)(object)val2.hurtBox) && Object.op_Implicit((Object)(object)val2.hurtBox.healthComponent)) ? val2.hurtBox.healthComponent.body : null);
				if (Object.op_Implicit((Object)(object)val3))
				{
					OnSpellHit(val3);
				}
			}
		}

		public override void OnExit()
		{
			if (!released)
			{
				AVVfxActor.Stop(castEffect);
			}
			((EntityState)this).OnExit();
		}

		public override InterruptPriority GetMinimumInterruptPriority()
		{
			if (released)
			{
				return (InterruptPriority)0;
			}
			return (InterruptPriority)2;
		}

		public override void OnSerialize(NetworkWriter writer)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			((BaseSkillState)this).OnSerialize(writer);
			writer.Write(targetObject);
			writer.Write(targetPoint);
		}

		public override void OnDeserialize(NetworkReader reader)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			((BaseSkillState)this).OnDeserialize(reader);
			targetObject = reader.ReadGameObject();
			targetPoint = reader.ReadVector3();
		}
	}
	public sealed class AerogaIVState : AVSpellState
	{
		protected override string Directory => "airo";

		protected override float DamageCoefficient => 14f;

		protected override float BlastRadius => 16f;

		protected override bool AreaTargets => true;

		protected override int[] PulseFrames => new int[2] { 30, 90 };

		protected override int DamageHits => 4;

		protected override float ProcCoefficient => 0.6f;

		protected override DamageSource Source => (DamageSource)2;
	}
	public sealed class TornadoIIState : AVSpellState
	{
		private static readonly int[] Ticks = new int[12]
		{
			70, 90, 110, 130, 150, 170, 190, 210, 230, 250,
			270, 290
		};

		protected override string Directory => "toln";

		protected override float DamageCoefficient => 24f;

		protected override float BlastRadius => 4f;

		protected override int DamageHits => Ticks.Length;

		protected override int[] PulseFrames => Ticks;

		protected override bool UsesHitMarkers => false;

		protected override float ProcCoefficient => 0.25f;

		protected override DamageSource Source => (DamageSource)4;

		protected override void OnSpellHit(CharacterBody target)
		{
			if (NetworkServer.active)
			{
				target.AddTimedBuff(AVBuffs.WindTorn, 8f);
			}
		}
	}
	public sealed class CometState : AVSpellState
	{
		protected override string Directory => "mete";

		protected override float DamageCoefficient => 35f;

		protected override float BlastRadius => 13f;

		protected override float EffectScaleMultiplier => 1.5f;

		protected override DamageSource Source => (DamageSource)8;

		protected override void OnReleased()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (((EntityState)this).isAuthority && ((EntityState)this).characterBody.GetBuffCount(AVBuffs.CometFocus) < 10)
			{
				((EntityState)this).characterBody.AddTimedBuffAuthority(AVBuffs.CometFocus.buffIndex, 20f);
			}
		}
	}
}
namespace AbsoluteVirtueSurvivor.Skills.Abilities
{
	public abstract class AVAbilityState : BaseSkillState
	{
		protected abstract string[] Directories { get; }

		protected virtual float Duration => 1.6f;

		public override void OnEnter()
		{
			((BaseState)this).OnEnter();
			string[] directories = Directories;
			foreach (string directory in directories)
			{
				AVVfx.Play(((EntityState)this).characterBody, "main", directory, Targets());
			}
			if (((EntityState)this).isAuthority)
			{
				Activate();
			}
		}

		private protected virtual IList<AVTarget> Targets()
		{
			return null;
		}

		protected abstract void Activate();

		public override void FixedUpdate()
		{
			((EntityState)this).FixedUpdate();
			if (((EntityState)this).isAuthority && ((EntityState)this).fixedAge >= Duration)
			{
				((EntityState)this).outer.SetNextStateToMain();
			}
		}

		public override InterruptPriority GetMinimumInterruptPriority()
		{
			return (InterruptPriority)2;
		}
	}
	public sealed class BenedictionState : AVAbilityState
	{
		private const float Radius = 40f;

		private bool healed;

		protected override string[] Directories => new string[1] { "kami" };

		private protected override IList<AVTarget> Targets()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			List<AVTarget> list = new List<AVTarget>();
			foreach (TeamComponent teamMember in TeamComponent.GetTeamMembers(((BaseState)this).GetTeam()))
			{
				CharacterBody val = (Object.op_Implicit((Object)(object)teamMember) ? teamMember.body : null);
				if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val.healthComponent) || !val.healthComponent.alive)
				{
					continue;
				}
				Vector3 val2 = val.corePosition - ((EntityState)this).characterBody.corePosition;
				if (!(((Vector3)(ref val2)).sqrMagnitude > 1600f))
				{
					list.Add(AVTarget.Of(val));
					if (list.Count >= 8)
					{
						break;
					}
				}
			}
			return list;
		}

		protected override void Activate()
		{
		}

		public override void FixedUpdate()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			base.FixedUpdate();
			if (healed || ((EntityState)this).fixedAge < 1.2f)
			{
				return;
			}
			healed = true;
			if (!NetworkServer.active)
			{
				return;
			}
			foreach (AVTarget item in Targets())
			{
				item.Body.healthComponent.HealFraction(1f, default(ProcChainMask));
				Util.CleanseBody(item.Body, true, false, false, true, true, false);
			}
		}
	}
	public sealed class BloodWeaponState : AVAbilityState
	{
		protected override string[] Directories => new string[1] { "blad" };

		protected override void Activate()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			((EntityState)this).characterBody.AddTimedBuffAuthority(AVBuffs.BloodWeapon.buffIndex, 30f);
		}
	}
	public sealed class FervorState : AVAbilityState
	{
		protected override string[] Directories => new string[2] { "renz", "hyak" };

		protected override void Activate()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			((EntityState)this).characterBody.AddTimedBuffAuthority(AVBuffs.Fervor.buffIndex, 45f);
		}
	}
	public sealed class PerfectDodgeState : AVAbilityState
	{
		protected override string[] Directories => new string[1] { "touz" };

		protected override float Duration => 0.8f;

		protected override void Activate()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			((EntityState)this).characterBody.AddTimedBuffAuthority(AVBuffs.PerfectDodge.buffIndex, 10f);
			((EntityState)this).characterBody.AddTimedBuffAuthority(Buffs.HiddenInvincibility.buffIndex, 10f);
		}
	}
}
namespace AbsoluteVirtueSurvivor.Core
{
	internal static class AVConfig
	{
		internal static ConfigEntry<float> EffectScale;

		internal static ConfigEntry<float> PolearmHitboxScale;

		internal static ConfigEntry<float> ApotheosisCooldownDivisor;

		internal static ConfigEntry<bool> FfxiCastTimes;

		internal static ConfigEntry<float> FastCastTime;

		internal static ConfigEntry<KeyboardShortcut> StanceKey;

		internal static ConfigEntry<bool> CameraShake;

		internal static ConfigEntry<bool> Voice;

		internal static ConfigEntry<float> AerogaCooldown;

		internal static ConfigEntry<float> TornadoCooldown;

		internal static ConfigEntry<float> CometCooldown;

		internal static ConfigEntry<float> BenedictionCooldown;

		internal static ConfigEntry<float> BloodWeaponCooldown;

		internal static ConfigEntry<float> FervorCooldown;

		internal static ConfigEntry<float> PerfectDodgeCooldown;

		internal static float CastTime
		{
			get
			{
				if (!FfxiCastTimes.Value)
				{
					return Mathf.Max(0f, FastCastTime.Value);
				}
				return 10f;
			}
		}

		internal static void Init(ConfigFile config)
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			EffectScale = config.Bind<float>("Visuals", "FFXI effect scale", 3.5f, "World size of one FFXI unit for the original effects. 3.5 matches AV's model scale.");
			PolearmHitboxScale = config.Bind<float>("Gameplay", "Polearm hitbox scale", 2.5f, "Multiplier on the polearm attack volumes (1 = exactly the weapon).");
			ApotheosisCooldownDivisor = config.Bind<float>("Gameplay", "Apotheosis spell cooldown divisor", 3f, "While Apotheosis (Chainspell) lasts, spells are instant and their cooldown is divided by this.");
			CameraShake = config.Bind<bool>("Visuals", "Camera shake", true, "Play the camera shakes authored in the FFXI effects (Comet, Aeroga IV...).");
			Voice = config.Bind<bool>("Audio", "Absolute Virtue voice", true, "Play AV's FFXI attack / hurt voice lines.");
			FfxiCastTimes = config.Bind<bool>("Gameplay", "FFXI cast times", true, "Use FFXI's 10 second cast times for Aeroga IV, Tornado II and Comet (AV can move while casting).");
			FastCastTime = config.Bind<float>("Gameplay", "Cast time", 1.5f, "Cast time in seconds when FFXI cast times are disabled.");
			StanceKey = config.Bind<KeyboardShortcut>("Controls", "Stance key", new KeyboardShortcut((KeyCode)102, Array.Empty<KeyCode>()), "Keyboard key that switches between the Magic and Ability stances (gamepad: D-pad left).");
			AerogaCooldown = config.Bind<float>("Cooldowns", "Aeroga IV", 50f, "FFXI recast: 50s");
			TornadoCooldown = config.Bind<float>("Cooldowns", "Tornado II", 60f, "FFXI recast: 60s");
			CometCooldown = config.Bind<float>("Cooldowns", "Comet", 45f, "FFXI recast: 45s");
			BenedictionCooldown = config.Bind<float>("Cooldowns", "Benediction", 60f, "Seconds per charge (2 charges: 120s to refill both)");
			BloodWeaponCooldown = config.Bind<float>("Cooldowns", "Blood Weapon", 90f, "FFXI recast: 120s");
			FervorCooldown = config.Bind<float>("Cooldowns", "Apotheosis", 60f, "Chainspell + Hundred Fists + Mighty Strikes");
			PerfectDodgeCooldown = config.Bind<float>("Cooldowns", "Perfect Dodge", 60f, "FFXI recast: 60s");
		}
	}
	internal static class AVContent
	{
		internal static void AddBody(GameObject bodyPrefab)
		{
			AVContentPackProvider.BodyPrefabs.Add(bodyPrefab);
		}

		internal static void AddMaster(GameObject masterPrefab)
		{
			AVContentPackProvider.MasterPrefabs.Add(masterPrefab);
		}

		internal static void AddSurvivor(SurvivorDef survivorDef)
		{
			AVContentPackProvider.SurvivorDefs.Add(survivorDef);
		}

		internal static void AddSkillDef(SkillDef skillDef)
		{
			AVContentPackProvider.SkillDefs.Add(skillDef);
		}

		internal static void AddSkillFamily(SkillFamily skillFamily)
		{
			AVContentPackProvider.SkillFamilies.Add(skillFamily);
		}

		internal static void AddEntityState(Type entityStateType)
		{
			AVContentPackProvider.EntityStateTypes.Add(entityStateType);
		}
	}
	internal sealed class AVContentPackProvider : IContentPackProvider
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static CollectContentPackProvidersDelegate <0>__AddProvider;
		}

		private readonly ContentPack _contentPack = new ContentPack();

		internal static readonly List<GameObject> BodyPrefabs = new List<GameObject>();

		internal static readonly List<GameObject> MasterPrefabs = new List<GameObject>();

		internal static readonly List<SurvivorDef> SurvivorDefs = new List<SurvivorDef>();

		internal static readonly List<SkillDef> SkillDefs = new List<SkillDef>();

		internal static readonly List<SkillFamily> SkillFamilies = new List<SkillFamily>();

		internal static readonly List<Type> EntityStateTypes = new List<Type>();

		public string identifier => "com.abyssano78.absolutevirtuesurvivor";

		internal static void Register()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__AddProvider;
			if (obj == null)
			{
				CollectContentPackProvidersDelegate val = AddProvider;
				<>O.<0>__AddProvider = val;
				obj = (object)val;
			}
			ContentManager.collectContentPackProviders += (CollectContentPackProvidersDelegate)obj;
		}

		private static void AddProvider(AddContentPackProviderDelegate addContentPackProvider)
		{
			addContentPackProvider.Invoke((IContentPackProvider)(object)new AVContentPackProvider());
		}

		public IEnumerator LoadStaticContentAsync(LoadStaticContentAsyncArgs args)
		{
			_contentPack.identifier = identifier;
			_contentPack.bodyPrefabs.Add(BodyPrefabs.ToArray());
			_contentPack.masterPrefabs.Add(MasterPrefabs.ToArray());
			_contentPack.survivorDefs.Add(SurvivorDefs.ToArray());
			_contentPack.skillDefs.Add(SkillDefs.ToArray());
			_contentPack.skillFamilies.Add(SkillFamilies.ToArray());
			_contentPack.entityStateTypes.Add(EntityStateTypes.ToArray());
			args.ReportProgress(1f);
			yield break;
		}

		public IEnumerator GenerateContentPackAsync(GetContentPackAsyncArgs args)
		{
			ContentPack.Copy(_contentPack, args.output);
			args.ReportProgress(1f);
			yield break;
		}

		public IEnumerator FinalizeAsync(FinalizeAsyncArgs args)
		{
			args.ReportProgress(1f);
			yield break;
		}
	}
	internal static class AVIcons
	{
		private static readonly Dictionary<string, Sprite> sprites = new Dictionary<string, Sprite>();

		internal static void Init(AssetBundle bundle)
		{
			if (!Object.op_Implicit((Object)(object)bundle))
			{
				return;
			}
			Sprite[] array = bundle.LoadAllAssets<Sprite>();
			foreach (Sprite val in array)
			{
				if (((Object)val).name.StartsWith("AVIcon_"))
				{
					sprites[((Object)val).name.Substring(7)] = val;
				}
			}
			Log.Info($"{sprites.Count} skill icons");
		}

		internal static Sprite Get(string id)
		{
			if (!sprites.TryGetValue(id, out var value))
			{
				return null;
			}
			return value;
		}
	}
}
namespace AbsoluteVirtueSurvivor.Character
{
	public class AVDeathState : GenericCharacterDeath
	{
		private const float BodyLifetime = 5f;

		public override bool shouldAutoDestroy => false;

		public override void OnEnter()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			((GenericCharacterDeath)this).OnEnter();
			if (Object.op_Implicit((Object)(object)((EntityState)this).characterMotor))
			{
				((EntityState)this).characterMotor.velocity = Vector3.zero;
			}
			AVAnimationDriver component = ((EntityState)this).GetComponent<AVAnimationDriver>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.SetLocomotionLocked(locked: true);
			}
			if ((Object)(object)AVVfx.Play(((EntityState)this).characterBody, "dead", "tens/tens", null, null, 1f, 1f, detachedSounds: true) == (Object)null)
			{
				AVVfxActor.Get(((EntityState)this).characterBody)?.PlayState("ded0", 5f);
			}
		}

		public override void PlayDeathAnimation(float crossfadeDuration = 0.1f)
		{
		}

		public override void FixedUpdate()
		{
			((GenericCharacterDeath)this).FixedUpdate();
			if (NetworkServer.active && ((EntityState)this).fixedAge > 5f)
			{
				EntityState.Destroy((Object)(object)((EntityState)this).gameObject);
			}
		}

		public override InterruptPriority GetMinimumInterruptPriority()
		{
			return (InterruptPriority)9;
		}
	}
	internal sealed class AVLifecycle : MonoBehaviour
	{
		private CharacterBody body;

		private bool introPlayed;

		private float lastHurtVoice;

		private float startTime;

		private void Start()
		{
			body = ((Component)this).GetComponent<CharacterBody>();
			startTime = Time.time;
			AVVfxActor.Get(body);
		}

		private void Update()
		{
			if (!introPlayed && Object.op_Implicit((Object)(object)body) && AVVfx.Ready && !((Object)(object)body.currentVehicle != (Object)null) && !(Time.time - startTime < 0.5f))
			{
				introPlayed = true;
				AVVfx.Play(body, "app3", "tens/tens");
			}
		}

		internal static void HalveDamageOverTime(orig_TakeDamageProcess orig, HealthComponent self, DamageInfo damageInfo)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_0039: 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)
			if (Object.op_Implicit((Object)(object)self) && damageInfo != null && Object.op_Implicit((Object)(object)self.body) && Object.op_Implicit((Object)(object)((Component)self.body).GetComponent<AVLifecycle>()) && ((int)damageInfo.dotIndex != -1 || (damageInfo.damageType.damageType & 0x4000000) != 0))
			{
				damageInfo.damage *= 0.5f;
			}
			orig.Invoke(self, damageInfo);
		}

		internal static void OnTakeDamage(DamageReport report)
		{
			CharacterBody val = report?.victimBody;
			if (Object.op_Implicit((Object)(object)val) && AVConfig.Voice.Value)
			{
				AVLifecycle component = ((Component)val).GetComponent<AVLifecycle>();
				if (Object.op_Implicit((Object)(object)component) && !(Time.time - component.lastHurtVoice < 4f) && !(report.damageDealt < val.healthComponent.fullCombinedHealth * 0.08f))
				{
					component.lastHurtVoice = Time.time;
					AVVfx.Play(val, "vdam", "tens/tens");
				}
			}
		}
	}
	public sealed class AVAnimationDriver : MonoBehaviour
	{
		private static readonly int IdleState = Animator.StringToHash("Base Layer.btl0");

		private static readonly int WalkState = Animator.StringToHash("Base Layer.1lk0");

		private static readonly int RunState = Animator.StringToHash("Base Layer.1un0");

		private CharacterBody _body;

		private CharacterMotor _motor;

		private ModelLocator _modelLocator;

		private Animator _animator;

		private int _requestedState;

		private bool _locomotionLocked;

		private const float MoveThresholdSquared = 0.04f;

		private const float CrossFadeDuration = 0.12f;

		private float _motionLockUntil;

		private void Awake()
		{
			ResolveReferences();
		}

		private void Start()
		{
			ResolveReferences();
			PlayState(IdleState, immediate: true);
		}

		private void ResolveReferences()
		{
			_body = ((Component)this).GetComponent<CharacterBody>();
			_motor = ((Component)this).GetComponent<CharacterMotor>();
			_modelLocator = ((Component)this).GetComponent<ModelLocator>();
			if ((Object)(object)_modelLocator != (Object)null && (Object)(object)_modelLocator.modelTransform != (Object)null)
			{
				Animator[] componentsInChildren = ((Component)_modelLocator.modelTransform).GetComponentsInChildren<Animator>(true);
				foreach (Animator val in componentsInChildren)
				{
					if ((Object)(object)val != (Object)null && val.layerCount > 0 && val.HasState(0, IdleState))
					{
						_animator = val;
						break;
					}
				}
			}
			if ((Object)(object)_animator == (Object)null)
			{
				Animator[] componentsInChildren = ((Component)this).GetComponentsInChildren<Animator>(true);
				foreach (Animator val2 in componentsInChildren)
				{
					if ((Object)(object)val2 != (Object)null && val2.layerCount > 0 && val2.HasState(0, IdleState))
					{
						_animator = val2;
						break;
					}
				}
			}
			if ((Object)(object)_animator != (Object)null)
			{
				((Behaviour)_animator).enabled = true;
				_animator.speed = 1f;
				_animator.applyRootMotion = false;
				_animator.cullingMode = (AnimatorCullingMode)0;
				_animator.updateMode = (AnimatorUpdateMode)0;
			}
		}

		public void SetLocomotionLocked(bool locked)
		{
			_locomotionLocked = locked;
		}

		public void LockFor(float seconds)
		{
			_motionLockUntil = Mathf.Max(_motionLockUntil, Time.time + seconds);
			_requestedState = 0;
		}

		public void ReleaseMotionLock()
		{
			_motionLockUntil = 0f;
			_requestedState = 0;
		}

		public void ForceRefresh()
		{
			_requestedState = 0;
		}

		private void Update()
		{
			if (!_locomotionLocked && !(Time.time < _motionLockUntil))
			{
				if ((Object)(object)_animator == (Object)null || (Object)(object)_body == (Object)null)
				{
					ResolveReferences();
				}
				else
				{
					UpdateLocomotionAnimation();
				}
			}
		}

		private void UpdateLocomotionAnimation()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			if ((Object)(object)_motor != (Object)null)
			{
				Vector3 velocity = _motor.velocity;
				velocity.y = 0f;
				flag = ((Vector3)(ref velocity)).sqrMagnitude > 0.04f;
			}
			int stateHash = ((!flag) ? IdleState : ((!_body.isSprinting) ? WalkState : RunState));
			PlayState(stateHash, immediate: false);
		}

		private void PlayState(int stateHash, bool immediate)
		{
			//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_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)
			if ((Object)(object)_animator == (Object)null)
			{
				return;
			}
			if (!_animator.HasState(0, stateHash))
			{
				Debug.LogError((object)$"[AbsoluteVirtue] Animator state missing: {stateHash}");
				return;
			}
			AnimatorStateInfo currentAnimatorStateInfo = _animator.GetCurrentAnimatorStateInfo(0);
			AnimatorStateInfo nextAnimatorStateInfo = _animator.GetNextAnimatorStateInfo(0);
			bool num = ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).fullPathHash == stateHash;
			bool flag = _animator.IsInTransition(0) && ((AnimatorStateInfo)(ref nextAnimatorStateInfo)).fullPathHash == stateHash;
			if (num || flag)
			{
				_requestedState = stateHash;
				return;
			}
			if (immediate)
			{
				_animator.Play(stateHash, 0, 0f);
			}
			else
			{
				_animator.CrossFade(stateHash, 0.12f, 0, 0f);
			}
			_requestedState = stateHash;
		}
	}
	public static class AVBody
	{
		private static readonly Quaternion VisualAxisCorrection = Quaternion.Euler(0f, -90f, 0f);

		public static GameObject BodyPrefab { get; private set; }

		public static GameObject DisplayPrefab { get; private set; }

		public static bool Initialize(GameObject visualPrefab)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)visualPrefab == (Object)null)
			{
				Debug.LogError((object)"[AbsoluteVirtue] Visual prefab is null.");
				return false;
			}
			GameObject val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Commando/CommandoBody.prefab").WaitForCompletion();
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogError((object)"[AbsoluteVirtue] Could not load CommandoBody.");
				return false;
			}
			BodyPrefab = PrefabAPI.InstantiateClone(val, "AbsoluteVirtueBody", true);
			CharacterBody component = BodyPrefab.GetComponent<CharacterBody>();
			ModelLocator component2 = BodyPrefab.GetComponent<ModelLocator>();
			CharacterDirection component3 = BodyPrefab.GetComponent<CharacterDirection>();
			if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null || (Object)(object)component2.modelBaseTransform == (Object)null)
			{
				Debug.LogError((object)"[AbsoluteVirtue] Cloned body lacks required components.");
				BodyPrefab = null;
				return false;
			}
			Transform modelTransform = component2.modelTransform;
			if ((Object)(object)modelTransform != (Object)null)
			{
				Renderer[] componentsInChildren = ((Component)modelTransform).GetComponentsInChildren<Renderer>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].enabled = false;
				}
				((Component)modelTransform).gameObject.SetActive(false);
			}
			GameObject val2 = new GameObject("AbsoluteVirtueModelRoot");
			Transform transform = val2.transform;
			transform.SetParent(component2.modelBaseTransform, false);
			transform.localPosition = Vector3.zero;
			transform.localRotation = Quaternion.identity;
			transform.localScale = Vector3.one;
			GameObject val3 = Object.Instantiate<GameObject>(visualPrefab, transform);
			((Object)val3).name = "AbsoluteVirtueVisual";
			val3.transform.localPosition = Vector3.zero;
			val3.transform.localRotation = VisualAxisCorrection;
			val3.transform.localScale = Vector3.one * 3.5f;
			val3.SetActive(true);
			component2.modelTransform = transform;
			ConfigureHurtBox(transform, modelTransform, component);
			Animator componentInChildren = val3.GetComponentInChildren<Animator>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Debug.LogError((object)"[AbsoluteVirtue] No Animator found on the AV model.");
				return false;
			}
			((Behaviour)componentInChildren).enabled = true;
			componentInChildren.speed = 1f;
			componentInChildren.applyRootMotion = false;
			componentInChildren.cullingMode = (AnimatorCullingMode)0;
			componentInChildren.updateMode = (AnimatorUpdateMode)0;
			if ((Object)(object)component3 != (Object)null)
			{
				component3.targetTransform = component2.modelBaseTransform;
				component3.overrideAnimatorForwardTransform = null;
				component3.rootMotionAccumulator = null;
				component3.modelAnimator = componentInChildren;
				component3.driveFromRootRotation = false;
				component3.turnSpeed = 720f;
			}
			ConfigureCameraAndAim(BodyPrefab, component);
			ConfigureCameraDistance(BodyPrefab);
			ConfigureCharacterModel(val2, component);
			ConfigurePolearmHitBoxes(val3);
			BodyPrefab.AddComponent<AVAnimationDriver>();
			BodyPrefab.AddComponent<AVLifecycle>();
			CharacterDeathBehavior component4 = BodyPrefab.GetComponent<CharacterDeathBehavior>();
			if ((Object)(object)component4 != (Object)null)
			{
				component4.deathState = new SerializableEntityStateType(typeof(AVDeathState));
				AVContent.AddEntityState(typeof(AVDeathState));
			}
			Sprite val4 = AVIcons.Get("Portrait");
			if ((Object)(object)val4 != (Object)null)
			{
				component.portraitIcon = (Texture)(object)val4.texture;
			}
			component.baseNameToken = "ABSOLUTE_VIRTUE_NAME";
			component.subtitleNameToken = "ABSOLUTE_VIRTUE_SUBTITLE";
			component.baseMaxHealth = 500f;
			component.levelMaxHealth = 210f;
			component.baseRegen = 5f;
			component.levelRegen = 0.5f;
			component.baseDamage = 16f;
			component.levelDamage = 2.5f;
			component.baseMoveSpeed = 10.5f;
			component.baseAttackSpeed = 1.5f;
			component.baseAcceleration = 80f;
			component.baseJumpPower = 15f;
			component.baseArmor = 20f;
			component.baseCrit = 5f;
			if (!CreateDisplayPrefab(visualPrefab))
			{
				return false;
			}
			Transform obj = DisplayPrefab.transform.Find("AbsoluteVirtueDisplayRoot");
			ConfigureSkins(val2, (obj != null) ? ((Component)obj).gameObject : null);
			AVContent.AddBody(BodyPrefab);
			Debug.Log((object)"[AbsoluteVirtue] Body created with explicit locomotion animation, Henry-style CharacterDirection, and farther camera.");
			return true;
		}

		private static void ConfigureHurtBox(Transform modelRoot, Transform vanillaModel, CharacterBody body)
		{
			//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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)vanillaModel != (Object)null)
			{
				HurtBox[] componentsInChildren = ((Component)vanillaModel).GetComponentsInChildren<HurtBox>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Component)componentsInChildren[i]).gameObject.SetActive(false);
				}
				HurtBoxGroup[] componentsInChildren2 = ((Component)vanillaModel).GetComponentsInChildren<HurtBoxGroup>(