using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AttackDirectionFix.Patches;
using AttackDirectionFix.Utils;
using BepInEx;
using BepInEx.Logging;
using HG;
using HG.Reflection;
using HarmonyLib;
using IL.RoR2.Projectile;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MonoMod.Utils;
using On.RoR2;
using On.RoR2.Projectile;
using R2API.Utils;
using RoR2;
using RoR2.ConVar;
using RoR2.Projectile;
using UnityEngine;

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace AttackDirectionFix
{
	internal static class Log
	{
		private static readonly StringBuilder _sharedStringBuilder;

		private static readonly int _cachedCallerPathPrefixLength;

		private static ManualLogSource _logSource;

		static Log()
		{
			_sharedStringBuilder = new StringBuilder(256);
			_cachedCallerPathPrefixLength = getCallerPathPrefixLength("X:\\Git\\RoR2\\AttackDirectionFix\\AttackDirectionFix\\Log.cs");
			static int getCallerPathPrefixLength([CallerFilePath] string callerPath = null)
			{
				int num = callerPath.LastIndexOf("AttackDirectionFix\\");
				if (num >= 0)
				{
					return num + "AttackDirectionFix\\".Length;
				}
				Debug.LogError((object)"[AttackDirectionFix] Logger failed to determine caller path prefix length");
				return 0;
			}
		}

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

		private static StringBuilder AppendCallerPrefix(this StringBuilder stringBuilder, string callerPath, string callerMemberName, int callerLineNumber)
		{
			return stringBuilder.Append(callerPath, _cachedCallerPathPrefixLength, callerPath.Length - _cachedCallerPathPrefixLength).Append(':').Append(callerLineNumber)
				.Append(" (")
				.Append(callerMemberName)
				.Append("):");
		}

		private static StringBuilder buildCallerLogString(string callerPath, string callerMemberName, int callerLineNumber, object data)
		{
			return _sharedStringBuilder.Clear().AppendCallerPrefix(callerPath, callerMemberName, callerLineNumber).Append(' ')
				.Append(data);
		}

		[Conditional("DEBUG")]
		internal static void Debug(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
		{
			_logSource.LogDebug((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Conditional("DEBUG")]
		internal static void Debug_NoCallerPrefix(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
		{
			_logSource.LogError((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Error_NoCallerPrefix(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
		{
			_logSource.LogFatal((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Fatal_NoCallerPrefix(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
		{
			_logSource.LogInfo((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Info_NoCallerPrefix(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
		{
			_logSource.LogMessage((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Message_NoCallerPrefix(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
		{
			_logSource.LogWarning((object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Warning_NoCallerPrefix(object data)
		{
			_logSource.LogWarning(data);
		}

		internal static void LogType(LogLevel level, object data, [CallerFilePath] string callerPath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = -1)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: 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)
			if ((level & 0x20) == 0)
			{
				_logSource.Log(level, (object)buildCallerLogString(callerPath, callerMemberName, callerLineNumber, data));
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void LogType_NoCallerPrefix(LogLevel level, object data)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: 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)
			if ((level & 0x20) == 0)
			{
				_logSource.Log(level, data);
			}
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("Gorakh.AttackDirectionFix", "AttackDirectionFix", "1.2.3")]
	public class Main : BaseUnityPlugin
	{
		public const string PluginGUID = "Gorakh.AttackDirectionFix";

		public const string PluginAuthor = "Gorakh";

		public const string PluginName = "AttackDirectionFix";

		public const string PluginVersion = "1.2.3";

		private void Awake()
		{
			Stopwatch stopwatch = Stopwatch.StartNew();
			Log.Init(((BaseUnityPlugin)this).Logger);
			AimOriginOverridePatch.Init();
			ProjectileGhostOffsetPatch.Init();
			PlayerAimVisualizer.Init();
			stopwatch.Stop();
			Log.Info_NoCallerPrefix($"Initialized in {stopwatch.Elapsed.TotalSeconds:F2} seconds");
		}
	}
	internal static class PlayerAimVisualizer
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static SceneCameraDelegate <0>__SceneCameraPreCull;
		}

		private static GameObject _aimOriginVisualizer;

		private static GameObject _cameraPivotVisualizer;

		private static readonly BoolConVar _cvEnableAimVisualization = new BoolConVar("debug_aim_visualization", (ConVarFlags)0, "0", "Enables/Disables player aim visualization. Green=Aim Origin, Red=Camera Pivot");

		public static void Init()
		{
			//IL_0034: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			_aimOriginVisualizer = GameObject.CreatePrimitive((PrimitiveType)0);
			Object.DontDestroyOnLoad((Object)(object)_aimOriginVisualizer);
			_aimOriginVisualizer.GetComponent<Collider>().enabled = false;
			_aimOriginVisualizer.GetComponent<Renderer>().material.color = Color.green;
			_aimOriginVisualizer.transform.localScale = Vector3.one * 0.1f;
			_cameraPivotVisualizer = GameObject.CreatePrimitive((PrimitiveType)0);
			Object.DontDestroyOnLoad((Object)(object)_cameraPivotVisualizer);
			_cameraPivotVisualizer.GetComponent<Collider>().enabled = false;
			_cameraPivotVisualizer.GetComponent<Renderer>().material.color = Color.red;
			_cameraPivotVisualizer.transform.localScale = Vector3.one * 0.1f;
			object obj = <>O.<0>__SceneCameraPreCull;
			if (obj == null)
			{
				SceneCameraDelegate val = SceneCameraPreCull;
				<>O.<0>__SceneCameraPreCull = val;
				obj = (object)val;
			}
			SceneCamera.onSceneCameraPreCull += (SceneCameraDelegate)obj;
		}

		private static void SceneCameraPreCull(SceneCamera sceneCamera)
		{
			//IL_008a: 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)
			if (Object.op_Implicit((Object)(object)_aimOriginVisualizer))
			{
				_aimOriginVisualizer.SetActive(false);
			}
			if (Object.op_Implicit((Object)(object)_cameraPivotVisualizer))
			{
				_cameraPivotVisualizer.SetActive(false);
			}
			if (!_cvEnableAimVisualization.value)
			{
				return;
			}
			CameraRigController cameraRigController = sceneCamera.cameraRigController;
			if (Object.op_Implicit((Object)(object)cameraRigController) && cameraRigController.localUserViewer != null)
			{
				CharacterBody targetBody = cameraRigController.targetBody;
				if (Object.op_Implicit((Object)(object)targetBody) && Object.op_Implicit((Object)(object)_aimOriginVisualizer))
				{
					_aimOriginVisualizer.SetActive(true);
					_aimOriginVisualizer.transform.position = targetBody.inputBank.aimOrigin;
				}
				CameraTargetParams targetParams = cameraRigController.targetParams;
				if (Object.op_Implicit((Object)(object)targetParams) && Object.op_Implicit((Object)(object)targetParams.cameraPivotTransform) && Object.op_Implicit((Object)(object)_cameraPivotVisualizer))
				{
					_cameraPivotVisualizer.SetActive(true);
					_cameraPivotVisualizer.transform.position = targetParams.cameraPivotTransform.position;
				}
			}
		}
	}
	public static class ProjectileAttributeTracker
	{
		private class ProjectileMovementTracker : MonoBehaviour
		{
			private const float MovementEpsilon = 0.1f;

			private ProjectileController _projectileController;

			private Vector3 _startPosition;

			private bool _hasMoved;

			private void Awake()
			{
				_projectileController = ((Component)this).GetComponent<ProjectileController>();
			}

			private void Start()
			{
				//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)
				_startPosition = ((Component)this).transform.position;
			}

			private void FixedUpdate()
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				if (!_hasMoved)
				{
					Vector3 val = ((Component)this).transform.position - _startPosition;
					if (((Vector3)(ref val)).sqrMagnitude >= 0.010000001f)
					{
						_hasMoved = true;
					}
				}
			}

			private void OnDestroy()
			{
				reportProjectileStationary(Object.op_Implicit((Object)(object)_projectileController) ? _projectileController.catalogIndex : (-1), !_hasMoved);
			}
		}

		private static bool[] _isStationaryLookup = Array.Empty<bool>();

		[SystemInitializer(new Type[] { typeof(ProjectileCatalog) })]
		private static void Init()
		{
			if (ProjectileCatalog.projectilePrefabCount <= 0)
			{
				return;
			}
			_isStationaryLookup = new bool[ProjectileCatalog.projectilePrefabCount];
			ProjectileSimple val = default(ProjectileSimple);
			BoomerangProjectile val2 = default(BoomerangProjectile);
			CleaverProjectile val3 = default(CleaverProjectile);
			DaggerController val4 = default(DaggerController);
			MissileController val5 = default(MissileController);
			ProjectileCharacterController val6 = default(ProjectileCharacterController);
			ProjectileOwnerOrbiter val7 = default(ProjectileOwnerOrbiter);
			SoulSearchController val8 = default(SoulSearchController);
			Rigidbody val9 = default(Rigidbody);
			for (int i = 0; i < ProjectileCatalog.projectilePrefabCount; i++)
			{
				GameObject projectilePrefab = ProjectileCatalog.GetProjectilePrefab(i);
				if (Object.op_Implicit((Object)(object)projectilePrefab))
				{
					bool flag = (!projectilePrefab.TryGetComponent<ProjectileSimple>(ref val) || (!(val.desiredForwardSpeed > 0f) && !val.oscillate)) && (!projectilePrefab.TryGetComponent<BoomerangProjectile>(ref val2) || !(val2.travelSpeed > 0f)) && (!projectilePrefab.TryGetComponent<CleaverProjectile>(ref val3) || !(val3.travelSpeed > 0f)) && (!projectilePrefab.TryGetComponent<DaggerController>(ref val4) || !(val4.acceleration > 0f)) && (!projectilePrefab.TryGetComponent<MissileController>(ref val5) || (!(val5.maxVelocity > 0f) && !(val5.acceleration > 0f))) && (!projectilePrefab.TryGetComponent<ProjectileCharacterController>(ref val6) || !(val6.velocity > 0f)) && (!projectilePrefab.TryGetComponent<ProjectileOwnerOrbiter>(ref val7) || !(val7.degreesPerSecond > 0f)) && (!projectilePrefab.TryGetComponent<SoulSearchController>(ref val8) || !(val8.maxVelocity > 0f)) && (!projectilePrefab.TryGetComponent<Rigidbody>(ref val9) || val9.isKinematic);
					_isStationaryLookup[i] = flag;
					projectilePrefab.AddComponent<ProjectileMovementTracker>();
				}
			}
		}

		private static void reportProjectileStationary(int projectileIndex, bool stationary)
		{
			if (ArrayUtils.IsInBounds<bool>(_isStationaryLookup, projectileIndex) && _isStationaryLookup[projectileIndex] != stationary)
			{
				_isStationaryLookup[projectileIndex] = stationary;
			}
			GameObject projectilePrefab = ProjectileCatalog.GetProjectilePrefab(projectileIndex);
			ProjectileMovementTracker projectileMovementTracker = default(ProjectileMovementTracker);
			if (Object.op_Implicit((Object)(object)projectilePrefab) && projectilePrefab.TryGetComponent<ProjectileMovementTracker>(ref projectileMovementTracker))
			{
				Object.Destroy((Object)(object)projectileMovementTracker);
			}
		}

		public static bool IsStationaryProjectile(int projectileIndex)
		{
			return ArrayUtils.GetSafe<bool>(_isStationaryLookup, projectileIndex);
		}
	}
	public class ProjectileInitialOffset : MonoBehaviour
	{
		public float StartTime;

		public Vector3 InitialPositionOffset;

		public Quaternion InitialRotationOffset = Quaternion.identity;

		public float InterpolationTime;

		private float age => Time.time - StartTime;

		private float interpolationFraction => Mathf.Pow(Mathf.Clamp01(age / InterpolationTime), 1f / 3f);

		public Vector3 CurrentPositionOffset => Vector3.Lerp(InitialPositionOffset, Vector3.zero, interpolationFraction);

		public Quaternion CurrentRotationOffset => Quaternion.Lerp(InitialRotationOffset, Quaternion.identity, interpolationFraction);

		private void FixedUpdate()
		{
			if (age >= InterpolationTime)
			{
				Object.Destroy((Object)(object)this);
			}
		}
	}
}
namespace AttackDirectionFix.Utils
{
	public static class CameraRigUtils
	{
		public static CameraRigController FindCameraRigControllerForBody(CharacterBody body)
		{
			return ((IEnumerable<CameraRigController>)CameraRigController.readOnlyInstancesList).FirstOrDefault((Func<CameraRigController, bool>)((CameraRigController c) => (Object)(object)c.targetBody == (Object)(object)body));
		}
	}
	public static class VectorUtils
	{
		public static Vector3 ClosestPointAlongRay(Ray ray, Vector3 target)
		{
			//IL_0002: 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_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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			return ((Ray)(ref ray)).origin + ((Ray)(ref ray)).direction * Vector3.Dot(((Ray)(ref ray)).direction, target - ((Ray)(ref ray)).origin);
		}
	}
}
namespace AttackDirectionFix.Patches
{
	internal static class AimOriginOverridePatch
	{
		private delegate Vector3 orig_get_aimOrigin(InputBankTest self);

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

			public static hook_FindBestInteractableObject <>9__1_0;

			internal GameObject <Init>b__1_0(orig_FindBestInteractableObject orig, InteractionDriver self)
			{
				_tempDisablePatch = true;
				try
				{
					return orig.Invoke(self);
				}
				finally
				{
					_tempDisablePatch = false;
				}
			}
		}

		private static bool _tempDisablePatch;

		public static void Init()
		{
			//IL_0034: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.DeclaredPropertyGetter(typeof(InputBankTest), "aimOrigin");
			if ((object)methodInfo != null)
			{
				new Hook((MethodBase)methodInfo, (Delegate)new Func<orig_get_aimOrigin, InputBankTest, Vector3>(InputBankTest_get_aimOrigin));
			}
			else
			{
				Log.Error_NoCallerPrefix("Unable to find InputBankTest.aimOrigin getter");
			}
			object obj = <>c.<>9__1_0;
			if (obj == null)
			{
				hook_FindBestInteractableObject val = delegate(orig_FindBestInteractableObject orig, InteractionDriver self)
				{
					_tempDisablePatch = true;
					try
					{
						return orig.Invoke(self);
					}
					finally
					{
						_tempDisablePatch = false;
					}
				};
				<>c.<>9__1_0 = val;
				obj = (object)val;
			}
			InteractionDriver.FindBestInteractableObject += (hook_FindBestInteractableObject)obj;
		}

		public static Vector3 GetUnalteredAimOrigin(this InputBankTest inputBankTest)
		{
			//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_0016: Unknown result type (might be due to invalid IL or missing references)
			_tempDisablePatch = true;
			try
			{
				return inputBankTest.aimOrigin;
			}
			finally
			{
				_tempDisablePatch = false;
			}
		}

		private static Vector3 InputBankTest_get_aimOrigin(orig_get_aimOrigin orig, InputBankTest self)
		{
			//IL_0002: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_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_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_0071: Unknown result type (might be due to invalid IL or missing references)
			Vector3 result = orig(self);
			if (!_tempDisablePatch)
			{
				CameraRigController val = CameraRigUtils.FindCameraRigControllerForBody(self.characterBody);
				if (Object.op_Implicit((Object)(object)val))
				{
					CameraTargetParams targetParams = val.targetParams;
					if (Object.op_Implicit((Object)(object)targetParams) && Object.op_Implicit((Object)(object)targetParams.cameraPivotTransform))
					{
						Vector3 position = targetParams.cameraPivotTransform.position;
						CameraState currentCameraState = val.currentCameraState;
						return VectorUtils.ClosestPointAlongRay(new Ray(currentCameraState.position, currentCameraState.rotation * Vector3.forward), position);
					}
				}
			}
			return result;
		}
	}
	public class ProjectileDisplacementInfoProvider : MonoBehaviour
	{
		private class DisplacementData
		{
			public FireProjectileInfo OriginalFireProjectileInfo { get; private set; }

			public DisplacementData(FireProjectileInfo originalFireProjectileInfo)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				OriginalFireProjectileInfo = originalFireProjectileInfo;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__modifyFirePosition;

			public static <>A{00000009}<FireProjectileInfo, DisplacementData> <1>__tryModifyFireInfo;

			public static Action<GameObject, FireProjectileInfo, DisplacementData> <2>__handleProjectileInstantiate;
		}

		public FireProjectileInfo UnmodifiedFireProjectileInfo { get; private set; }

		public FireProjectileInfo ModifiedFireProjectileInfo { get; private set; }

		[SystemInitializer(new Type[] { })]
		private static void Init()
		{
			//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
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			object obj = <>O.<0>__modifyFirePosition;
			if (obj == null)
			{
				Manipulator val = modifyFirePosition;
				<>O.<0>__modifyFirePosition = val;
				obj = (object)val;
			}
			ProjectileManager.FireProjectileServer += (Manipulator)obj;
			object obj2 = <>O.<0>__modifyFirePosition;
			if (obj2 == null)
			{
				Manipulator val2 = modifyFirePosition;
				<>O.<0>__modifyFirePosition = val2;
				obj2 = (object)val2;
			}
			ProjectileManager.FireProjectileClient += (Manipulator)obj2;
			static void handleProjectileInstantiate(GameObject projectile, FireProjectileInfo fireProjectileInfo, DisplacementData displacementData)
			{
				//IL_0014: 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)
				if (Object.op_Implicit((Object)(object)projectile) && displacementData != null)
				{
					ProjectileDisplacementInfoProvider projectileDisplacementInfoProvider = projectile.AddComponent<ProjectileDisplacementInfoProvider>();
					projectileDisplacementInfoProvider.UnmodifiedFireProjectileInfo = displacementData.OriginalFireProjectileInfo;
					projectileDisplacementInfoProvider.ModifiedFireProjectileInfo = fireProjectileInfo;
				}
			}
			static void modifyFirePosition(ILContext il)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Expected O, but got Unknown
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val7 = new ILCursor(il);
				ParameterDefinition val8 = ((IEnumerable<ParameterDefinition>)((MethodReference)il.Method).Parameters).FirstOrDefault((Func<ParameterDefinition, bool>)((ParameterDefinition p) => Extensions.Is((MemberReference)(object)((ParameterReference)p).ParameterType, (MemberInfo)typeof(FireProjectileInfo))));
				if (val8 == null)
				{
					Log.Error("Failed to find FireProjectileInfo parameter", "X:\\Git\\RoR2\\AttackDirectionFix\\AttackDirectionFix\\Patches\\ProjectileDisplacementInfoProvider.cs", "Init", 38);
				}
				else
				{
					VariableDefinition val9 = new VariableDefinition(il.Import(typeof(DisplacementData)));
					il.Method.Body.Variables.Add(val9);
					val7.Emit(OpCodes.Ldarga, val8);
					val7.Emit(OpCodes.Ldloca, val9);
					val7.EmitDelegate<<>A{00000009}<FireProjectileInfo, DisplacementData>>((<>A{00000009}<FireProjectileInfo, DisplacementData>)tryModifyFireInfo);
					if (val7.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
					{
						(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)SymbolExtensions.GetMethodInfo((Expression<Action>)(() => Object.Instantiate<GameObject>((GameObject)null, default(Vector3), default(Quaternion)))))
					}))
					{
						val7.Emit(OpCodes.Dup);
						val7.Emit(OpCodes.Ldarg, val8);
						val7.Emit(OpCodes.Ldloc, val9);
						val7.EmitDelegate<Action<GameObject, FireProjectileInfo, DisplacementData>>((Action<GameObject, FireProjectileInfo, DisplacementData>)handleProjectileInstantiate);
					}
					else
					{
						Log.Error("Failed to find instantiate call", "X:\\Git\\RoR2\\AttackDirectionFix\\AttackDirectionFix\\Patches\\ProjectileDisplacementInfoProvider.cs", "Init", 106);
					}
				}
			}
			static void tryModifyFireInfo(ref FireProjectileInfo fireProjectileInfo, ref DisplacementData displacementData)
			{
				//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_0050: 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)
				//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_007d: 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)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				CharacterBody val3 = default(CharacterBody);
				if (Object.op_Implicit((Object)(object)fireProjectileInfo.owner) && fireProjectileInfo.owner.TryGetComponent<CharacterBody>(ref val3) && val3.isPlayerControlled && !ProjectileAttributeTracker.IsStationaryProjectile(ProjectileCatalog.GetProjectileIndex(fireProjectileInfo.projectilePrefab)))
				{
					InputBankTest inputBank = val3.inputBank;
					if (Object.op_Implicit((Object)(object)inputBank))
					{
						Vector3 val4 = fireProjectileInfo.position;
						Vector3 val5 = val4 - inputBank.aimOrigin;
						if (((Vector3)(ref val5)).sqrMagnitude < Mathf.Epsilon)
						{
							val4 = inputBank.GetUnalteredAimOrigin();
						}
						float bestFitRadius = val3.bestFitRadius;
						float num = bestFitRadius * bestFitRadius;
						Vector3 val6 = val3.corePosition - val4;
						if (!(((Vector3)(ref val6)).sqrMagnitude > num))
						{
							FireProjectileInfo originalFireProjectileInfo = fireProjectileInfo;
							originalFireProjectileInfo.position = val4;
							displacementData = new DisplacementData(originalFireProjectileInfo);
							fireProjectileInfo.position = inputBank.aimOrigin;
						}
					}
				}
			}
		}
	}
	internal static class ProjectileGhostOffsetPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__ProjectileController_Start;

			public static hook_LerpTransform <1>__ProjectileGhostController_LerpTransform;

			public static hook_CopyTransform <2>__ProjectileGhostController_CopyTransform;

			public static hook_TrySticking <3>__ProjectileStickOnImpact_TrySticking;

			public static <>A{00000490}<ProjectileController, bool, Vector3, Quaternion> <4>__getOffsets;

			public static Func<Vector3, Vector3, Vector3> <5>__getVisualPosition;

			public static Func<Quaternion, Quaternion, Quaternion> <6>__getVisualRotation;

			public static Action<ProjectileController, bool, Vector3, Quaternion> <7>__initializeGhostOffset;
		}

		private static readonly FloatConVar _cvProjectileInterpolationTime = new FloatConVar("projectile_visual_interp", (ConVarFlags)0, "0.7", "[Attack Direction Fix] How long projectile visuals should take to interpolate to their actual path");

		public static void Init()
		{
			//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
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//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_005b: Expected O, but got Unknown
			//IL_0070: 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_007b: Expected O, but got Unknown
			object obj = <>O.<0>__ProjectileController_Start;
			if (obj == null)
			{
				Manipulator val = ProjectileController_Start;
				<>O.<0>__ProjectileController_Start = val;
				obj = (object)val;
			}
			ProjectileController.Start += (Manipulator)obj;
			object obj2 = <>O.<1>__ProjectileGhostController_LerpTransform;
			if (obj2 == null)
			{
				hook_LerpTransform val2 = ProjectileGhostController_LerpTransform;
				<>O.<1>__ProjectileGhostController_LerpTransform = val2;
				obj2 = (object)val2;
			}
			ProjectileGhostController.LerpTransform += (hook_LerpTransform)obj2;
			object obj3 = <>O.<2>__ProjectileGhostController_CopyTransform;
			if (obj3 == null)
			{
				hook_CopyTransform val3 = ProjectileGhostController_CopyTransform;
				<>O.<2>__ProjectileGhostController_CopyTransform = val3;
				obj3 = (object)val3;
			}
			ProjectileGhostController.CopyTransform += (hook_CopyTransform)obj3;
			object obj4 = <>O.<3>__ProjectileStickOnImpact_TrySticking;
			if (obj4 == null)
			{
				hook_TrySticking val4 = ProjectileStickOnImpact_TrySticking;
				<>O.<3>__ProjectileStickOnImpact_TrySticking = val4;
				obj4 = (object)val4;
			}
			ProjectileStickOnImpact.TrySticking += (hook_TrySticking)obj4;
		}

		private static void ProjectileController_Start(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			VariableDefinition val2 = new VariableDefinition(il.Import(typeof(bool)));
			il.Method.Body.Variables.Add(val2);
			VariableDefinition positionOffsetVar = new VariableDefinition(il.Import(typeof(Vector3)));
			il.Method.Body.Variables.Add(positionOffsetVar);
			VariableDefinition rotationOffsetVar = new VariableDefinition(il.Import(typeof(Quaternion)));
			il.Method.Body.Variables.Add(rotationOffsetVar);
			val.Emit(OpCodes.Ldarg_0);
			val.Emit(OpCodes.Ldloca, val2);
			val.Emit(OpCodes.Ldloca, positionOffsetVar);
			val.Emit(OpCodes.Ldloca, rotationOffsetVar);
			val.EmitDelegate<<>A{00000490}<ProjectileController, bool, Vector3, Quaternion>>((<>A{00000490}<ProjectileController, bool, Vector3, Quaternion>)getOffsets);
			VariableDefinition rotationTempVar = new VariableDefinition(il.Import(typeof(Quaternion)));
			il.Method.Body.Variables.Add(rotationTempVar);
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)SymbolExtensions.GetMethodInfo((Expression<Action>)(() => Object.Instantiate<GameObject>((GameObject)null, default(Vector3), default(Quaternion)))))
			}))
			{
				emitPositionRotationOffset(val);
			}
			else
			{
				Log.Error("Failed to find non-pooled ghost instantiate patch location", "X:\\Git\\RoR2\\AttackDirectionFix\\AttackDirectionFix\\Patches\\ProjectileGhostOffsetPatch.cs", "ProjectileController_Start", 104);
			}
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)SymbolExtensions.GetMethodInfo((Expression<Action>)(() => EffectManager.GetAndActivatePooledEffect((GameObject)null, default(Vector3), default(Quaternion)))))
			}))
			{
				emitPositionRotationOffset(val);
			}
			else
			{
				Log.Error("Failed to find pooled ghost instantiate patch location", "X:\\Git\\RoR2\\AttackDirectionFix\\AttackDirectionFix\\Patches\\ProjectileGhostOffsetPatch.cs", "ProjectileController_Start", 114);
			}
			if (val.TryGotoNext((MoveType)1, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchRet(x)
			}))
			{
				val.Emit(OpCodes.Ldarg_0);
				val.Emit(OpCodes.Ldloc, val2);
				val.Emit(OpCodes.Ldloc, positionOffsetVar);
				val.Emit(OpCodes.Ldloc, rotationOffsetVar);
				val.EmitDelegate<Action<ProjectileController, bool, Vector3, Quaternion>>((Action<ProjectileController, bool, Vector3, Quaternion>)initializeGhostOffset);
			}
			else
			{
				Log.Error("Failed to find ret match", "X:\\Git\\RoR2\\AttackDirectionFix\\AttackDirectionFix\\Patches\\ProjectileGhostOffsetPatch.cs", "ProjectileController_Start", 156);
			}
			void emitPositionOffset(ILCursor c)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				c.Emit(OpCodes.Ldloc, positionOffsetVar);
				c.EmitDelegate<Func<Vector3, Vector3, Vector3>>((Func<Vector3, Vector3, Vector3>)getVisualPosition);
			}
			void emitPositionRotationOffset(ILCursor c)
			{
				//IL_0001: 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)
				c.Emit(OpCodes.Stloc, rotationTempVar);
				emitPositionOffset(c);
				c.Emit(OpCodes.Ldloc, rotationTempVar);
				emitRotationOffset(c);
			}
			void emitRotationOffset(ILCursor c)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				c.Emit(OpCodes.Ldloc, rotationOffsetVar);
				c.EmitDelegate<Func<Quaternion, Quaternion, Quaternion>>((Func<Quaternion, Quaternion, Quaternion>)getVisualRotation);
			}
			static void getOffsets(ProjectileController projectileController, out bool hasVisualOffset, out Vector3 positionOffset, out Quaternion rotationOffset)
			{
				//IL_0004: 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_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: 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_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				hasVisualOffset = false;
				positionOffset = Vector3.zero;
				rotationOffset = Quaternion.identity;
				ProjectileDisplacementInfoProvider projectileDisplacementInfoProvider = default(ProjectileDisplacementInfoProvider);
				if (Object.op_Implicit((Object)(object)projectileController) && ((Component)projectileController).TryGetComponent<ProjectileDisplacementInfoProvider>(ref projectileDisplacementInfoProvider))
				{
					FireProjectileInfo unmodifiedFireProjectileInfo = projectileDisplacementInfoProvider.UnmodifiedFireProjectileInfo;
					FireProjectileInfo modifiedFireProjectileInfo = projectileDisplacementInfoProvider.ModifiedFireProjectileInfo;
					Vector3 val3 = unmodifiedFireProjectileInfo.position - modifiedFireProjectileInfo.position;
					hasVisualOffset = true;
					positionOffset = val3;
				}
			}
			static Vector3 getVisualPosition(Vector3 position, Vector3 offset)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return position + offset;
			}
			static Quaternion getVisualRotation(Quaternion rotation, Quaternion offset)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return rotation * offset;
			}
			static void initializeGhostOffset(ProjectileController projectileController, bool hasVisualOffset, Vector3 positionOffset, Quaternion rotationOffset)
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: 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)
				if (Object.op_Implicit((Object)(object)projectileController))
				{
					ProjectileGhostController ghost = projectileController.ghost;
					if (Object.op_Implicit((Object)(object)ghost))
					{
						ProjectileInitialOffset projectileInitialOffset = ((Component)ghost).GetComponent<ProjectileInitialOffset>();
						if (hasVisualOffset)
						{
							if (!Object.op_Implicit((Object)(object)projectileInitialOffset))
							{
								projectileInitialOffset = ((Component)ghost).gameObject.AddComponent<ProjectileInitialOffset>();
							}
							projectileInitialOffset.StartTime = Time.time;
							projectileInitialOffset.InitialPositionOffset = positionOffset;
							projectileInitialOffset.InitialRotationOffset = rotationOffset;
							projectileInitialOffset.InterpolationTime = _cvProjectileInterpolationTime.value;
						}
						else if (Object.op_Implicit((Object)(object)projectileInitialOffset))
						{
							Object.Destroy((Object)(object)projectileInitialOffset);
						}
					}
				}
			}
		}

		private static void ProjectileGhostController_LerpTransform(orig_LerpTransform orig, ProjectileGhostController self, Transform a, Transform b, float t)
		{
			orig.Invoke(self, a, b, t);
			tryApplyOffset(self);
		}

		private static void ProjectileGhostController_CopyTransform(orig_CopyTransform orig, ProjectileGhostController self, Transform src)
		{
			orig.Invoke(self, src);
			tryApplyOffset(self);
		}

		private static void tryApplyOffset(ProjectileGhostController ghostController)
		{
			//IL_001a: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			ProjectileInitialOffset projectileInitialOffset = default(ProjectileInitialOffset);
			if (Object.op_Implicit((Object)(object)ghostController) && ((Component)ghostController).TryGetComponent<ProjectileInitialOffset>(ref projectileInitialOffset))
			{
				Transform transform = ghostController.transform;
				transform.position += projectileInitialOffset.CurrentPositionOffset;
				transform.rotation *= projectileInitialOffset.CurrentRotationOffset;
			}
		}

		private static bool ProjectileStickOnImpact_TrySticking(orig_TrySticking orig, ProjectileStickOnImpact self, Collider hitCollider, Vector3 impactNormal)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			bool num = orig.Invoke(self, hitCollider, impactNormal);
			ProjectileController val = default(ProjectileController);
			if (num && Object.op_Implicit((Object)(object)self) && ((Component)self).TryGetComponent<ProjectileController>(ref val))
			{
				ProjectileGhostController ghost = val.ghost;
				ProjectileInitialOffset projectileInitialOffset = default(ProjectileInitialOffset);
				if (Object.op_Implicit((Object)(object)ghost) && ((Component)ghost).TryGetComponent<ProjectileInitialOffset>(ref projectileInitialOffset))
				{
					Object.Destroy((Object)(object)projectileInitialOffset);
				}
			}
			return num;
		}
	}
}