using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using R2API.Utils;
using RoR2;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("NoVolcanicEgg")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("NoVolcanicEgg")]
[assembly: AssemblyTitle("NoVolcanicEgg")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace ExamplePlugin;

internal static class Log
{
	internal static ManualLogSource _logSource;

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

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

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

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

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

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

	internal static void LogWarning(object data)
	{
		_logSource.LogWarning(data);
	}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("1nsider.NoChaoticVolcanic", "NoChaoticVolcanic", "1.0.0")]
[R2APISubmoduleDependency(new string[] { "ItemAPI", "LanguageAPI" })]
public class RemoveEgg : BaseUnityPlugin
{
	public const string PluginGUID = "1nsider.NoChaoticVolcanic";

	public const string PluginAuthor = "1nsider";

	public const string PluginName = "NoChaoticVolcanic";

	public const string PluginVersion = "1.0.0";

	public void Awake()
	{
		Log.Init(((BaseUnityPlugin)this).Logger);
	}

	public void Update()
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: 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)
		if (EquipmentCatalog.randomTriggerEquipmentList.Contains(EquipmentCatalog.FindEquipmentIndex("FireBallDash")))
		{
			EquipmentCatalog.randomTriggerEquipmentList.Remove(EquipmentCatalog.FindEquipmentIndex("FireBallDash"));
		}
		if (EquipmentCatalog.randomTriggerEquipmentList.Contains(EquipmentCatalog.FindEquipmentIndex("Gateway")))
		{
			EquipmentCatalog.randomTriggerEquipmentList.Remove(EquipmentCatalog.FindEquipmentIndex("Gateway"));
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.Railgunner.Scope;
using HG.BlendableTypes;
using HG.GeneralSerializer;
using MonoMod.RuntimeDetour;
using On.EntityStates.Railgunner.Scope;
using On.RoR2;
using On.RoR2.CameraModes;
using On.RoR2.CharacterAI;
using RailCharges.Configuration;
using RailCharges.Internals;
using RailCharges.Patches;
using RailCharges.Patches.BackupMagCharges;
using RailCharges.Resources;
using RoR2;
using RoR2.CameraModes;
using RoR2.CharacterAI;
using RoR2.UI;
using TMPro;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("RailCharges")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Displays available charges count for Railgunner with Backup Magazines")]
[assembly: AssemblyFileVersion("0.2.1.0")]
[assembly: AssemblyInformationalVersion("0.2.1")]
[assembly: AssemblyProduct("RailCharges")]
[assembly: AssemblyTitle("RailCharges")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.1.0")]
[module: UnverifiableCode]
namespace RailCharges
{
	public class CurrentPlayerTracker
	{
		private static PlayerCharacterMasterController cachedCurrentMaster;

		public static CharacterBody CurrentPlayerBody
		{
			get
			{
				PlayerCharacterMasterController obj = cachedCurrentMaster;
				CharacterBody val = ((obj != null) ? obj.master.GetBody() : null);
				if (Object.op_Implicit((Object)(object)val))
				{
					return val;
				}
				cachedCurrentMaster = ((IEnumerable<PlayerCharacterMasterController>)PlayerCharacterMasterController.instances).FirstOrDefault((Func<PlayerCharacterMasterController, bool>)((PlayerCharacterMasterController c) => ((NetworkBehaviour)c.networkUser).isLocalPlayer));
				PlayerCharacterMasterController obj2 = cachedCurrentMaster;
				val = ((obj2 != null) ? obj2.master.GetBody() : null);
				if (!Object.op_Implicit((Object)(object)val))
				{
					RailChargesPlugin.Log.LogInfo((object)"Local player body found!");
				}
				return val;
			}
		}

		public static void Init()
		{
		}
	}
	public static class Helpers
	{
		public static T GetPrefabFromEntityStateConfiguration<T>(string assetName, string prefabFieldName) where T : Object
		{
			//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_0031: 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)
			return (T)(object)Addressables.LoadAssetAsync<EntityStateConfiguration>((object)assetName).WaitForCompletion().serializedFieldsCollection.serializedFields.First((SerializedField sf) => sf.fieldName == prefabFieldName).fieldValue.objectValue;
		}

		public static void Exec(Action action, Action after)
		{
			try
			{
				action();
				after();
			}
			catch (Exception ex)
			{
				RailChargesPlugin.Log.LogError((object)ex);
			}
		}

		public static bool Raycast(CharacterBody characterBody, Ray ray, out RaycastHit hitInfo)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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 Util.CharacterRaycast(((Component)characterBody).gameObject, ray, ref hitInfo, 1000f, LayerMask.op_Implicit(LayerMask.op_Implicit(((LayerIndex)(ref LayerIndex.entityPrecise)).mask) | LayerMask.op_Implicit(((LayerIndex)(ref LayerIndex.world)).mask)), (QueryTriggerInteraction)0);
		}
	}
	[BepInPlugin("RailCharges", "RailCharges", "0.2.1")]
	public class RailChargesPlugin : BaseUnityPlugin
	{
		public static ManualLogSource Log;

		public static PluginConfig PluginConfig;

		public static CameraNudgeManager CameraNudgeManager;

		public static List<IPatch> Patches = new List<IPatch>();

		private DetourModManager detourModManager;

		private void Awake()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			PluginConfig = PluginConfig.Load(((BaseUnityPlugin)this).Config);
			detourModManager = new DetourModManager();
			CurrentPlayerTracker.Init();
			CameraNudgeManager = new CameraNudgeManager();
			SetupPatches();
			ResourceManager.Init();
			SceneManager.sceneLoaded += OnSceneManagerOnsceneLoaded;
			if (Object.op_Implicit((Object)(object)Stage.instance))
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Stage is running - patching");
				PatchAssets();
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin RailCharges is loaded!");
		}

		private void SetupPatches()
		{
			Patches = new List<IPatch>
			{
				new LightReticleChange(),
				new FasterWindup(),
				new CameraScopeParametersOverride(),
				new DisableBoostedIndicator()
			};
			if (PluginConfig.DisplayBackupMagazineCharges)
			{
				Patches.Add(new BackupMagChargesPatch());
			}
			if (PluginConfig.AngularCompensation)
			{
				Patches.Add(new AngularCompensationPatch(CameraNudgeManager));
			}
		}

		private void OnSceneManagerOnsceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
		{
			PatchAssets();
		}

		public void PatchAssets()
		{
			foreach (IPatch patch in Patches)
			{
				try
				{
					patch.Patch(PluginConfig);
				}
				catch (Exception arg)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)$"Error during patching: {arg}");
				}
			}
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneManagerOnsceneLoaded;
			detourModManager.Unload(typeof(RailChargesPlugin).Assembly);
			foreach (IPatch patch in Patches)
			{
				if (patch is IDisposable disposable)
				{
					disposable.Dispose();
				}
			}
		}

		private void LoggerOnLogEvent(object sender, LogEventArgs e)
		{
			Chat.AddMessage(e.Data?.ToString() ?? "");
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "RailCharges";

		public const string PLUGIN_NAME = "RailCharges";

		public const string PLUGIN_VERSION = "0.2.1";
	}
}
namespace RailCharges.Resources
{
	public class ResourceManager
	{
		private static Dictionary<string, Object> dict = new Dictionary<string, Object>();

		public static void Init()
		{
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("RailCharges.Resources.railcharges");
			AssetBundle val = AssetBundle.LoadFromStream(stream);
			dict["reticle"] = (Object)(object)val.LoadAsset<Sprite>("Assets/icons/reticle.png");
			val.Unload(false);
		}

		public static T Get<T>(string name) where T : Object
		{
			if (dict.TryGetValue(name, out var value))
			{
				return (T)(object)value;
			}
			return default(T);
		}
	}
}
namespace RailCharges.Patches
{
	public class AngularCompensationPatch : IPatch, IDisposable
	{
		private readonly CameraNudgeManager cameraNudgeManager;

		private PluginConfig config;

		public static CameraRigController CameraRigController => ((Component)((Component)Camera.main).gameObject.transform.parent).GetComponent<CameraRigController>();

		public AngularCompensationPatch(CameraNudgeManager cameraNudgeManager)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			this.cameraNudgeManager = cameraNudgeManager;
			BaseScopeState.StartScopeParamsOverride += new hook_StartScopeParamsOverride(OnBaseScopeStateOnStartScopeParamsOverride);
			BaseScopeState.EndScopeParamsOverride += (hook_EndScopeParamsOverride)delegate(orig_EndScopeParamsOverride orig, BaseScopeState self, float transitionDuration)
			{
				OnBaseScopeStateOnEndScopeParamsOverride(orig, self, transitionDuration);
			};
		}

		private void OnBaseScopeStateOnStartScopeParamsOverride(orig_StartScopeParamsOverride orig, BaseScopeState self, float transitionDuration)
		{
			Helpers.Exec(delegate
			{
				orig.Invoke(self, transitionDuration);
			}, delegate
			{
				if (config.AngularCompensation && self is WindUpScopeHeavy && ((NetworkBehaviour)((EntityState)self).characterBody.master.playerCharacterMasterController.networkUser).isLocalPlayer)
				{
					OnEnteringScope(((EntityState)self).characterBody);
				}
			});
		}

		private void OnBaseScopeStateOnEndScopeParamsOverride(orig_EndScopeParamsOverride orig, BaseScopeState self, float transitionDuration)
		{
			Helpers.Exec(delegate
			{
				orig.Invoke(self, transitionDuration);
			}, delegate
			{
				if (config.AngularCompensation && self is BaseWindDown && ((NetworkBehaviour)((EntityState)self).characterBody.master.playerCharacterMasterController.networkUser).isLocalPlayer)
				{
					OnExitingScope(((EntityState)self).characterBody);
				}
			});
		}

		public void Patch(PluginConfig config)
		{
			this.config = config;
		}

		private void OnEnteringScope(CharacterBody body)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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_00a1: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			cameraNudgeManager.Cancel();
			RailChargesPlugin.Log.LogInfo((object)"Entering scope");
			Transform transform = ((Component)Camera.main).transform;
			Ray ray = default(Ray);
			((Ray)(ref ray))..ctor(transform.position, transform.forward);
			if (Helpers.Raycast(body, ray, out var hitInfo))
			{
				RailChargesPlugin.Log.LogInfo((object)("Raycast hit " + ((Object)((Component)((RaycastHit)(ref hitInfo)).collider).gameObject).name));
				Vector3 val = CameraRigController.target.transform.position + new Vector3(0f, 0.5f, 0f);
				Quaternion val2 = Quaternion.LookRotation(((RaycastHit)(ref hitInfo)).point - val);
				RailChargesPlugin.Log.LogInfo((object)((Quaternion)(ref val2)).eulerAngles);
				CameraNudgeManager obj = cameraNudgeManager;
				float x = ((Quaternion)(ref val2)).eulerAngles.x;
				Quaternion rotation = transform.rotation;
				obj.Set(new Vector2(0f, AngleDifference(x, ((Quaternion)(ref rotation)).eulerAngles.x)), FasterWindup.WindupDuration);
			}
		}

		private void OnExitingScope(CharacterBody characterBody)
		{
			//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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0073: 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_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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			cameraNudgeManager.Cancel();
			RailChargesPlugin.Log.LogInfo((object)"Exiting scope");
			Transform transform = ((Component)Camera.main).transform;
			CharacterCameraParamsData basic = CharacterCameraParamsData.basic;
			Ray ray = default(Ray);
			((Ray)(ref ray))..ctor(transform.position, transform.forward);
			if (Helpers.Raycast(characterBody, ray, out var hitInfo))
			{
				Vector3 val = transform.position + transform.rotation * basic.idealLocalCameraPos.value + new Vector3(0f, basic.pivotVerticalOffset.value, 0f);
				Quaternion val2 = Quaternion.LookRotation(((RaycastHit)(ref hitInfo)).point - val);
				CameraNudgeManager obj = cameraNudgeManager;
				float x = ((Quaternion)(ref val2)).eulerAngles.x;
				Quaternion rotation = transform.rotation;
				obj.Set(new Vector2(0f, AngleDifference(x, ((Quaternion)(ref rotation)).eulerAngles.x)), 0.01f);
			}
		}

		public static float AngleDifference(float angle1, float angle2)
		{
			float num = (angle2 - angle1 + 180f) % 360f - 180f;
			if (!(num < -180f))
			{
				return num;
			}
			return num + 360f;
		}

		public void Dispose()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			BaseScopeState.StartScopeParamsOverride -= new hook_StartScopeParamsOverride(OnBaseScopeStateOnStartScopeParamsOverride);
			BaseScopeState.EndScopeParamsOverride -= (hook_EndScopeParamsOverride)delegate(orig_EndScopeParamsOverride orig, BaseScopeState self, float transitionDuration)
			{
				OnBaseScopeStateOnEndScopeParamsOverride(orig, self, transitionDuration);
			};
		}
	}
	public class CameraScopeParametersOverride : IPatch
	{
		public void Patch(PluginConfig config)
		{
			OverrideScopeCameraParameters(config);
		}

		private void OverrideScopeCameraParameters(PluginConfig config)
		{
			//IL_0016: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			Helpers.GetPrefabFromEntityStateConfiguration<CharacterCameraParams>("RoR2/DLC1/Railgunner/EntityStates.Railgunner.Scope.WindUpScopeHeavy.asset", "cameraParams").data.fov = new BlendableFloat
			{
				value = config.ScopeFov,
				alpha = 1f
			};
		}
	}
	public class DisableBoostedIndicator : IPatch, IDisposable
	{
		public void Patch(PluginConfig config)
		{
			if (config.DisabledBoostedIndicator)
			{
				Transform overlayPrefab = GetOverlayPrefab();
				for (int i = 0; i < overlayPrefab.childCount; i++)
				{
					((Component)overlayPrefab.GetChild(i)).gameObject.SetActive(false);
				}
				RailChargesPlugin.Log.LogError((object)"Disabled boost UI element.");
			}
		}

		public void Dispose()
		{
			Transform overlayPrefab = GetOverlayPrefab();
			for (int i = 0; i < overlayPrefab.childCount; i++)
			{
				((Component)overlayPrefab.GetChild(i)).gameObject.SetActive(true);
			}
		}

		private Transform GetOverlayPrefab()
		{
			return Helpers.GetPrefabFromEntityStateConfiguration<GameObject>("RoR2/DLC1/Railgunner/EntityStates.Railgunner.Reload.Boosted.asset", "overlayPrefab").transform;
		}
	}
	public class FasterWindup : IPatch
	{
		public static float WindupDuration = 0.1f;

		private PluginConfig config;

		public FasterWindup()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			BaseWindUp.OnEnter += new hook_OnEnter(BaseWindUpOnOnEnter);
		}

		private void BaseWindUpOnOnEnter(orig_OnEnter orig, BaseWindUp self)
		{
			if (config.WindUpDurationOverride != self.baseDuration)
			{
				self.baseDuration = config.WindUpDurationOverride;
				WindupDuration = self.baseDuration;
			}
			orig.Invoke(self);
		}

		public void Patch(PluginConfig config)
		{
			this.config = config;
		}
	}
	public interface IPatch
	{
		void Patch(PluginConfig config);
	}
	public class LightReticleChange : IPatch
	{
		public void Patch(PluginConfig config)
		{
			//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)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			if (config.Crosshair == CrosshairType.Unchanged && !config.RemoveOuterRectangle)
			{
				return;
			}
			GameObject val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/Railgunner/RailgunnerCrosshair.prefab").WaitForCompletion();
			Transform val2 = val.transform.Find("Scaler");
			if (!Object.op_Implicit((Object)(object)val2))
			{
				RailChargesPlugin.Log.LogError((object)"Cannot find Scaler - light scope wasn't patched!");
				return;
			}
			CrosshairController component = val.GetComponent<CrosshairController>();
			RectTransform scaler = (RectTransform)val2;
			if (config.RemoveOuterRectangle)
			{
				RemoveOuterRectangle(scaler);
			}
			switch (config.Crosshair)
			{
			case CrosshairType.X:
				CreateXCrosshair(scaler, component);
				break;
			case CrosshairType.SameAsScope:
				CreatePlusCrosshair(scaler, component);
				break;
			case CrosshairType.Remove:
				CreateNoRectangleCrosshair(scaler, component);
				break;
			case CrosshairType.Unchanged:
				return;
			}
			RailChargesPlugin.Log.LogInfo((object)"Scope reticles patched!");
		}

		private static void RemoveOuterRectangle(RectTransform scaler)
		{
			Transform val = ((Transform)scaler).parent.Find("Flavor, Ready");
			if (!Object.op_Implicit((Object)(object)val))
			{
				RailChargesPlugin.Log.LogWarning((object)"Cannot find outer rectangle to remove!");
				return;
			}
			for (int i = 0; i < val.childCount; i++)
			{
				((Component)val.GetChild(i)).gameObject.SetActive(false);
			}
			RailChargesPlugin.Log.LogInfo((object)"Outer rectangle removed");
		}

		public static void CreatePlusCrosshair(RectTransform scaler, CrosshairController controller)
		{
			//IL_000b: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: 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_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			DestroyExistingCrosshair(scaler);
			Transform val = Object.Instantiate<Transform>(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/Railgunner/RailgunnerScopeCrosshairHeavy.prefab").WaitForCompletion().transform.Find("Available"));
			((Component)val).transform.SetParent((Transform)(object)scaler);
			List<GameObject> list = new List<GameObject>(4);
			for (int i = 0; i < val.childCount; i++)
			{
				GameObject gameObject = ((Component)val.GetChild(i)).gameObject;
				if (((Object)gameObject).name == "Image")
				{
					list.Add(gameObject);
				}
			}
			List<SpritePosition> list2 = new List<SpritePosition>();
			int[][] array = new int[4][]
			{
				new int[2] { 1, 0 },
				new int[2] { -1, 0 },
				new int[2] { 0, 1 },
				new int[2] { 0, -1 }
			};
			for (int j = 0; j < array.Length; j++)
			{
				int num = array[j][0];
				int num2 = array[j][1];
				GameObject val2 = list[j];
				list2.Add(new SpritePosition
				{
					target = (RectTransform)val2.transform,
					zeroPosition = val2.transform.position + new Vector3((float)(-15 * num), (float)(-15 * num2)),
					onePosition = val2.transform.position + new Vector3((float)(50 * num), (float)(50 * num2))
				});
				val2.transform.SetParent((Transform)(object)scaler);
			}
			controller.spriteSpreadPositions = list2.ToArray();
		}

		private static void CreateXCrosshair(RectTransform scaler, CrosshairController controller)
		{
			DestroyExistingCrosshair(scaler);
			CreateCustomReticles(scaler, controller);
		}

		private static void DestroyExistingCrosshair(RectTransform scaler)
		{
			for (int i = 0; i < ((Transform)scaler).childCount; i++)
			{
				Object.Destroy((Object)(object)((Component)((Transform)scaler).GetChild(i)).gameObject);
			}
		}

		private static void CreateNoRectangleCrosshair(RectTransform scaler, CrosshairController controller)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < ((Transform)scaler).childCount; i++)
			{
				((Graphic)((Component)((Transform)scaler).GetChild(i)).gameObject.GetComponent<Image>()).color = Color.clear;
			}
		}

		public static void CreateCustomReticles(RectTransform scaler, CrosshairController controller)
		{
			//IL_0046: 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_005f: Expected O, but got Unknown
			//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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			List<SpritePosition> list = new List<SpritePosition>();
			int[] array = new int[2] { -1, 1 };
			int[] array2 = array;
			foreach (int num in array2)
			{
				int[] array3 = array;
				foreach (int num2 in array3)
				{
					GameObject val = CreateReticle(15 * num, 15 * num2);
					list.Add(new SpritePosition
					{
						target = (RectTransform)val.transform,
						zeroPosition = new Vector3((float)(15 * num), (float)(15 * num2)),
						onePosition = new Vector3((float)(50 * num), (float)(50 * num2))
					});
					val.transform.SetParent((Transform)(object)scaler);
				}
			}
			controller.spriteSpreadPositions = list.ToArray();
		}

		private static GameObject CreateReticle(int x, int y)
		{
			//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)
			//IL_0045: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0060: 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_009e: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject($"Reticle_{x}_{y}");
			Image obj = val.AddComponent<Image>();
			obj.sprite = ResourceManager.Get<Sprite>("reticle");
			((Graphic)obj).color = new Color(1f, 1f, 1f, 0.5f);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchoredPosition = new Vector2((float)x, (float)y);
			val2.sizeDelta = new Vector2(15f, 15f);
			if (x != y)
			{
				((Transform)val2).localRotation = Quaternion.Euler(0f, 180f, 0f);
			}
			return val;
		}
	}
}
namespace RailCharges.Patches.BackupMagCharges
{
	public class BackupMagChargesPatch : IPatch
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_OnSkillActivated <>9__0_0;

			internal void <Patch>b__0_0(orig_OnSkillActivated orig, CharacterBody self, GenericSkill skill)
			{
				try
				{
					orig.Invoke(self, skill);
					if (self.hasEffectiveAuthority && skill.skillNameToken == "RAILGUNNER_SNIPE_HEAVY_NAME" && ((NetworkBehaviour)self.master.playerCharacterMasterController.networkUser).isLocalPlayer)
					{
						ScopeTracker.UpdateCharges(self.skillLocator.primary);
					}
				}
				catch (Exception ex)
				{
					RailChargesPlugin.Log.LogError((object)ex);
				}
			}
		}

		public void Patch(PluginConfig config)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if (!config.DisplayBackupMagazineCharges)
			{
				return;
			}
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				hook_OnSkillActivated val = delegate(orig_OnSkillActivated orig, CharacterBody self, GenericSkill skill)
				{
					try
					{
						orig.Invoke(self, skill);
						if (self.hasEffectiveAuthority && skill.skillNameToken == "RAILGUNNER_SNIPE_HEAVY_NAME" && ((NetworkBehaviour)self.master.playerCharacterMasterController.networkUser).isLocalPlayer)
						{
							ScopeTracker.UpdateCharges(self.skillLocator.primary);
						}
					}
					catch (Exception ex)
					{
						RailChargesPlugin.Log.LogError((object)ex);
					}
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			CharacterBody.OnSkillActivated += (hook_OnSkillActivated)obj;
			PatchPrefab(Helpers.GetPrefabFromEntityStateConfiguration<GameObject>("RoR2/DLC1/Railgunner/EntityStates.Railgunner.Scope.ActiveScopeHeavy.asset", "crosshairOverridePrefab"));
			RailChargesPlugin.Log.LogInfo((object)"Heavy crosshair prefab patched!");
		}

		public static void PatchPrefab(GameObject prefab)
		{
			//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_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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			Component component = prefab.GetComponent(typeof(ScopeTracker).FullName);
			if (Object.op_Implicit((Object)(object)component))
			{
				Object.Destroy((Object)(object)component);
			}
			prefab.AddComponent<ScopeTracker>();
			GameObject val = new GameObject("charges");
			HGTextMeshProUGUI obj = val.AddComponent<HGTextMeshProUGUI>();
			((TMP_Text)obj).alpha = 0.1f;
			((TMP_Text)obj).fontSize = 30f;
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchoredPosition = new Vector2(50f, 0f);
			val2.offsetMin = new Vector2(5f, 0f);
			val2.offsetMax = new Vector2(95f, 0f);
			Transform parent = prefab.transform.Find("Available");
			((Transform)val2).SetParent(parent);
		}
	}
	public class ScopeTracker : MonoBehaviour
	{
		public static HGTextMeshProUGUI LastTextMesh;

		private HGTextMeshProUGUI textMesh;

		private void Start()
		{
			Transform obj = ((Component)this).gameObject.transform.Find("Available/charges");
			LastTextMesh = ((obj != null) ? ((Component)obj).GetComponent<HGTextMeshProUGUI>() : null);
			textMesh = LastTextMesh;
			if (!Object.op_Implicit((Object)(object)LastTextMesh))
			{
				RailChargesPlugin.Log.LogError((object)"Failed to find text mesh");
				return;
			}
			if (!Object.op_Implicit((Object)(object)CurrentPlayerTracker.CurrentPlayerBody))
			{
				RailChargesPlugin.Log.LogError((object)"Player body not found");
				return;
			}
			UpdateCharges(CurrentPlayerTracker.CurrentPlayerBody.skillLocator.secondary);
			SetReadyStatus(isReady: true);
		}

		private void Update()
		{
			if (Object.op_Implicit((Object)(object)LastTextMesh) && Object.op_Implicit((Object)(object)CurrentPlayerTracker.CurrentPlayerBody))
			{
				SetReadyStatus(CurrentPlayerTracker.CurrentPlayerBody.skillLocator.primary.CanExecute());
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)LastTextMesh == (Object)(object)textMesh)
			{
				LastTextMesh = null;
			}
		}

		public static void UpdateCharges(GenericSkill skill)
		{
			if (!Object.op_Implicit((Object)(object)LastTextMesh))
			{
				RailChargesPlugin.Log.LogInfo((object)"UpdateCharges: no LastTextMesh");
			}
			else if (skill.maxStock == 1)
			{
				((TMP_Text)LastTextMesh).text = "";
			}
			else
			{
				((TMP_Text)LastTextMesh).text = $"{skill.stock}";
			}
		}

		public static void SetReadyStatus(bool isReady)
		{
			if (Object.op_Implicit((Object)(object)LastTextMesh))
			{
				((TMP_Text)LastTextMesh).alpha = (isReady ? 0.5f : 0.1f);
			}
		}
	}
}
namespace RailCharges.Internals
{
	public class CameraNudgeManager
	{
		public class Nudge
		{
			public Vector2 Delta { get; set; }

			public Vector2 Progress { get; set; }

			public float Elapsed { get; set; }

			public float Duration { get; set; }

			public bool IsDone => Elapsed >= Duration;

			public Vector2 Tick(float deltaTime)
			{
				//IL_0021: 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_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_0033: 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_003a: 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)
				Elapsed += deltaTime;
				float num = Mathf.Clamp01(Elapsed / Duration);
				Vector2 val = Vector2.Lerp(Vector2.zero, Delta, num);
				Vector2 result = val - Progress;
				Progress = val;
				return result;
			}
		}

		private Nudge nudge;

		public CameraNudgeManager()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			CameraModeBase.CollectLookInput += new hook_CollectLookInput(CameraModeBaseOnCollectLookInput);
		}

		private void CameraModeBaseOnCollectLookInput(orig_CollectLookInput orig, CameraModeBase self, ref CameraModeContext context, out CollectLookInputResult result)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			orig.Invoke(self, ref context, ref result);
			if (nudge != null)
			{
				ref Vector2 lookInput = ref result.lookInput;
				lookInput += nudge.Tick(Time.deltaTime);
				if (nudge.IsDone)
				{
					RailChargesPlugin.Log.LogInfo((object)$"Nudge finished @{nudge.Elapsed}");
					Cancel();
				}
			}
		}

		public void Set(Vector2 delta, float duration)
		{
			//IL_0007: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			nudge = new Nudge
			{
				Delta = delta,
				Elapsed = 0f,
				Progress = Vector2.zero,
				Duration = duration
			};
			RailChargesPlugin.Log.LogInfo((object)$"Nudge was set {delta} {duration:00.00}");
		}

		public void Cancel()
		{
			nudge = null;
		}
	}
	public class FadingOverrideManager
	{
		public class FadeOverride
		{
			public CharacterModel Model { get; set; }

			public float Target { get; set; }

			public float TransitionTime { get; set; }

			public float StartValue { get; set; }

			public float Elapsed { get; set; }

			public void Update(float deltaTime)
			{
				if (Object.op_Implicit((Object)(object)Model))
				{
					Elapsed += deltaTime;
					float num = Mathf.Clamp(Elapsed, 0f, TransitionTime);
					Model.fade = Mathf.Lerp(StartValue, Target, num / TransitionTime);
				}
			}
		}

		private FadeOverride Override;

		public FadingOverrideManager()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			CharacterModel.RefreshObstructorsForCamera += new hook_RefreshObstructorsForCamera(CharacterModelOnRefreshObstructorsForCamera);
		}

		private void CharacterModelOnRefreshObstructorsForCamera(orig_RefreshObstructorsForCamera orig, CameraRigController camerarigcontroller)
		{
			try
			{
				orig.Invoke(camerarigcontroller);
				if (Override != null)
				{
					Override.Update(Time.deltaTime);
				}
			}
			catch (Exception ex)
			{
				RailChargesPlugin.Log.LogError((object)ex);
			}
		}

		public void SetOverride(CharacterModel model, float targetOverride, float transitionTime)
		{
			Override = new FadeOverride
			{
				Target = targetOverride,
				StartValue = model.fade,
				TransitionTime = transitionTime,
				Model = model
			};
		}

		public void RemoveOverride()
		{
			Override = null;
		}
	}
}
namespace RailCharges.Internals.Debug
{
	public class DebugCubes
	{
		private static Dictionary<Color, GameObject> cubes = new Dictionary<Color, GameObject>();

		public static void Clear()
		{
			foreach (GameObject value in cubes.Values)
			{
				Object.Destroy((Object)(object)value);
			}
			cubes.Clear();
		}

		public static void SetPosition(Color color, Vector3 position, float size = 0.1f)
		{
			//IL_0000: 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)
			GetOrCreateCube(color, size).transform.position = position;
		}

		public static GameObject GetOrCreateCube(Color color, float size = 0.1f)
		{
			//IL_0005: 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)
			//IL_0029: 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)
			if (cubes.TryGetValue(color, out var value) && Object.op_Implicit((Object)(object)value))
			{
				return value;
			}
			value = CreateDebugCube($"debug_cube_{color}", color, size);
			cubes[color] = value;
			return value;
		}

		private static GameObject CreateDebugCube(string name, Color color, float size = 0.1f)
		{
			//IL_0018: 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)
			GameObject obj = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)obj).name = name;
			obj.GetComponent<Renderer>().material.color = color;
			obj.layer = LayerMask.NameToLayer("Ignore Raycast");
			obj.transform.localScale = new Vector3(size, size, size);
			return obj;
		}
	}
	public class DisableAI
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_FixedUpdate <0>__BaseAIOnFixedUpdate;
		}

		public static bool Disabled { get; set; }

		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
			object obj = <>O.<0>__BaseAIOnFixedUpdate;
			if (obj == null)
			{
				hook_FixedUpdate val = BaseAIOnFixedUpdate;
				<>O.<0>__BaseAIOnFixedUpdate = val;
				obj = (object)val;
			}
			BaseAI.FixedUpdate += (hook_FixedUpdate)obj;
		}

		private static void BaseAIOnFixedUpdate(orig_FixedUpdate orig, BaseAI self)
		{
			if (!Disabled)
			{
				orig.Invoke(self);
			}
		}
	}
}
namespace RailCharges.Configuration
{
	public static class ConfigFileExtensions
	{
		public static BindCollection BindCollection(this ConfigFile config, string section = null)
		{
			return new BindCollection(config, section);
		}
	}
	public class BindCollection
	{
		private readonly ConfigFile config;

		public string Section { get; private set; }

		public List<ConfigEntryBase> Bindings { get; } = new List<ConfigEntryBase>();


		private Dictionary<ConfigEntryBase, Action> UpdateCallbacks { get; } = new Dictionary<ConfigEntryBase, Action>();


		public event Action OnChanged;

		public BindCollection(ConfigFile config, string section)
		{
			this.config = config;
			Section = section;
			this.config.SettingChanged += OnSettingChanged;
		}

		private void OnSettingChanged(object sender, SettingChangedEventArgs e)
		{
			if (UpdateCallbacks.TryGetValue(e.ChangedSetting, out var value))
			{
				value();
				this.OnChanged?.Invoke();
			}
		}

		public BindCollection Bind(Action<BindCollection> registrar)
		{
			registrar(this);
			return this;
		}

		public BindCollection Bind<TValue>(string key, string description, Action<TValue> set, TValue defaultValue = default(TValue))
		{
			ConfigEntry<TValue> binding = config.Bind<TValue>(Section, key, defaultValue, description);
			set(binding.Value);
			Bindings.Add((ConfigEntryBase)(object)binding);
			UpdateCallbacks.Add((ConfigEntryBase)(object)binding, delegate
			{
				set(binding.Value);
			});
			return this;
		}

		public BindCollection Bind<TValue>(string key, ConfigDescription configDescription, Action<TValue> set, TValue defaultValue = default(TValue))
		{
			ConfigEntry<TValue> binding = config.Bind<TValue>(Section, key, defaultValue, configDescription);
			set(binding.Value);
			Bindings.Add((ConfigEntryBase)(object)binding);
			UpdateCallbacks.Add((ConfigEntryBase)(object)binding, delegate
			{
				set(binding.Value);
			});
			return this;
		}
	}
	public enum CrosshairType
	{
		Unchanged,
		X,
		SameAsScope,
		Remove
	}
	public class PluginConfig
	{
		public bool DisplayBackupMagazineCharges { get; set; }

		public float ScopeFov { get; set; }

		public float WindUpDurationOverride { get; set; }

		public CrosshairType Crosshair { get; set; }

		public bool RemoveOuterRectangle { get; set; }

		public bool DisabledBoostedIndicator { get; set; }

		public bool AngularCompensation { get; set; }

		public static PluginConfig Load(ConfigFile config)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			PluginConfig pluginConfig = new PluginConfig();
			config.BindCollection("Rail Charges").Bind("Display Charges", "Display number of Backup Magazine charges in scope mode", delegate(bool v)
			{
				pluginConfig.DisplayBackupMagazineCharges = v;
			}, defaultValue: true).Bind("WindUp duration override", "Modify how long animation for entering scope mode will take. Default game value is 0.1.", delegate(float v)
			{
				pluginConfig.WindUpDurationOverride = v;
			}, 0.1f)
				.Bind("Scope FOV override", "Set FOV for scope mode. Lower value - greater zoom. Default game value is 30.", delegate(float v)
				{
					pluginConfig.ScopeFov = v;
				}, 30f)
				.Bind("Crosshair", new ConfigDescription("Crosshair in normal mode", (AcceptableValueBase)(object)new AcceptableValueList<string>(Enum.GetNames(typeof(CrosshairType))), Array.Empty<object>()), delegate(string v)
				{
					pluginConfig.Crosshair = ParseEnum<CrosshairType>(v);
				}, CrosshairType.Unchanged.ToString())
				.Bind("Remove Outer Rectangle", "Disable outer yellow rectangle in non-scope view.", delegate(bool v)
				{
					pluginConfig.RemoveOuterRectangle = v;
				}, defaultValue: false)
				.Bind("Disable Boosted Indicator", "Disable boosted indicator for boosted shot after successful reload.", delegate(bool v)
				{
					pluginConfig.DisabledBoostedIndicator = v;
				}, defaultValue: false)
				.Bind("Angular Compensation", "Compensate camera rotation to retain targeting when entering scope mode. If disabled, scope will be aiming a little bit lower than in normal mode as in original. (Experimental)", delegate(bool v)
				{
					pluginConfig.AngularCompensation = v;
				}, defaultValue: false);
			return pluginConfig;
		}

		private static T ParseEnum<T>(string name) where T : struct
		{
			Enum.TryParse<T>(name, out var result);
			return result;
		}
	}
}