using System;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using HG;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using RoR2;
using RoR2.Orbs;
using RoR2.Projectile;
using RobDriver;
using RobDriver.Modules;
using RobDriver.Modules.Components;
using RobDriver.Modules.Survivors;
using RobDriver.SkillStates.Driver;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("FixDriver")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("FixDriver")]
[assembly: AssemblyTitle("FixDriver")]
[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 FixDriver
{
	[BepInPlugin("_score.FixDriver", "FixDriver", "0.0.2")]
	public class FixDriverPlugin : BaseUnityPlugin
	{
		public const string PluginGUID = "_score.FixDriver";

		public const string PluginAuthor = "score";

		public const string PluginName = "FixDriver";

		public const string PluginVersion = "0.0.2";

		public void Awake()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (AccessTools.Field(typeof(DriverPlugin), "MODVERSION").GetValue(null) as string == "1.8.0")
			{
				new Harmony("_score.FixDriver").CreateClassProcessor(typeof(Fix)).Patch();
				return;
			}
			Debug.LogError((object)"Driver is fixed, uninstall this mod :)");
			Object.Destroy((Object)(object)this);
		}
	}
	[HarmonyPatch]
	public class Fix
	{
		[HarmonyPatch(typeof(Driver), "CreateHitboxes")]
		[HarmonyILManipulator]
		public static void BuffKnife(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdstr(x, "KnifeHitbox")
			}) && val.TryGotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 1.3f)
			}))
			{
				val.Next.Operand = 1.75f;
			}
			else
			{
				Debug.LogError((object)"CreateHitboxes");
			}
		}

		[HarmonyPatch(typeof(Assets), "PopulateAssets")]
		[HarmonyPostfix]
		public static void FixTracer()
		{
			GameObject coinOrbEffect = Assets.coinOrbEffect;
			((OrbEffect)coinOrbEffect.GetComponent<CoinOrbEffect>()).duration = 1f;
			coinOrbEffect.GetComponent<VFXAttributes>().DoNotPool = true;
			Assets.coinImpact.GetComponent<VFXAttributes>().DoNotPool = true;
			GameObject coinTracer = Assets.coinTracer;
			Object.DestroyImmediate((Object)(object)coinTracer.GetComponent<CoinTracer>());
			Tracer obj = coinTracer.AddComponent<Tracer>();
			obj.startTransform = coinTracer.transform.GetChild(2).GetChild(0);
			obj.beamObject = ((Component)coinTracer.transform.GetChild(2).GetChild(0)).gameObject;
			obj.beamDensity = 0.2f;
			obj.speed = 1000f;
			obj.headTransform = coinTracer.transform.GetChild(1);
			obj.tailTransform = coinTracer.transform.GetChild(2).GetChild(0);
			obj.length = 20f;
		}

		[HarmonyPatch(typeof(CoinController), "Start")]
		[HarmonyPrefix]
		public static void FixCoinStart(CoinController __instance)
		{
			((Component)__instance).gameObject.layer = LayerIndex.fakeActor.intVal;
			((MonoBehaviour)__instance).StartCoroutine("SwapBack");
		}

		[HarmonyPatch(typeof(CoinController), "OnIncomingDamageServer")]
		[HarmonyPrefix]
		public static bool FixCoinReciever(CoinController __instance, DamageInfo damageInfo)
		{
			if (Object.op_Implicit((Object)(object)__instance.iDrive) && (Object)(object)damageInfo.attacker == (Object)(object)((Component)__instance.iDrive).gameObject)
			{
				__instance.RicochetBullet(damageInfo);
			}
			else
			{
				damageInfo.rejected = true;
			}
			return false;
		}

		[HarmonyPatch(typeof(CoinRicochetOrb), "PickNextTarget")]
		[HarmonyPrefix]
		public static bool FixCoinOrb2(CoinRicochetOrb __instance, Vector3 position, ref HurtBox __result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			__instance.search = new BullseyeSearch
			{
				queryTriggerInteraction = (QueryTriggerInteraction)1,
				filterByDistinctEntity = false,
				filterByLoS = false,
				sortMode = (SortMode)1,
				teamMaskFilter = TeamMask.all,
				maxDistanceFilter = __instance.searchRadius,
				searchOrigin = position
			};
			__instance.search.RefreshCandidates();
			CoinController val = default(CoinController);
			foreach (HurtBox result in __instance.search.GetResults())
			{
				if (((Component)result.healthComponent).TryGetComponent<CoinController>(ref val))
				{
					if (val.canRicochet)
					{
						__result = result;
						break;
					}
				}
				else if (!Object.op_Implicit((Object)(object)__result) && Object.op_Implicit((Object)(object)result.healthComponent.body) && ((GenericDamageOrb)__instance).teamIndex != result.healthComponent.body.teamComponent.teamIndex)
				{
					__result = result;
				}
			}
			return false;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyILManipulator]
		public static void FixCoinSwap(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 0.25f)
			}))
			{
				val.Next.Operand = 0.1f;
			}
			else
			{
				Debug.LogError((object)"coinswap1");
			}
			if (val.TryGotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsflda(x, typeof(LayerIndex), "entityPrecise")
			}))
			{
				val.GotoPrev((MoveType)1, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0)
				});
				val.Emit(OpCodes.Ldarg_0);
				val.Emit(val.Next.Next.OpCode, val.Next.Next.Operand);
				val.EmitDelegate<Action<CoinController>>((Action<CoinController>)delegate(CoinController coin)
				{
					ProjectileController val2 = default(ProjectileController);
					if (((Component)coin).TryGetComponent<ProjectileController>(ref val2))
					{
						coin.iDrive = val2.owner.GetComponent<DriverController>();
					}
					HealthComponent val3 = default(HealthComponent);
					if (((Component)coin).TryGetComponent<HealthComponent>(ref val3))
					{
						IOnIncomingDamageServerReceiver value = (IOnIncomingDamageServerReceiver)(object)coin;
						if (!val3.onIncomingDamageReceivers.Contains(value))
						{
							ArrayUtils.ArrayAppend<IOnIncomingDamageServerReceiver>(ref val3.onIncomingDamageReceivers, ref value);
						}
					}
					HurtBox componentInChildren = ((Component)coin).GetComponentInChildren<HurtBox>();
					if (Object.op_Implicit((Object)(object)componentInChildren))
					{
						((Component)componentInChildren).gameObject.layer = LayerIndex.entityPrecise.intVal;
					}
				});
				val.GotoNext(new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchLdsflda(x, typeof(LayerIndex), "entityPrecise")
				});
				val.Remove();
				val.Emit<LayerIndex>(OpCodes.Ldsflda, "defaultLayer");
			}
			else
			{
				Debug.LogError((object)"coinswap2");
			}
		}

		[HarmonyPatch(typeof(Driver), "CreateSkills")]
		[HarmonyILManipulator]
		public static void AddCoin(ILContext il)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: 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)
			ILCursor[] array = null;
			ILCursor[] array2 = null;
			if (new ILCursor(il).TryFindNext(ref array, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, typeof(Skills), "AddSpecialSkills"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, typeof(Skills), "AddSpecialSkills")
			}))
			{
				ILCursor val = array[0];
				TypeReference val3 = default(TypeReference);
				val.FindPrev(ref array2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchNewarr(x, ref val3)
				});
				array2[0].Prev.OpCode = OpCodes.Ldc_I4_7;
				val.Emit(OpCodes.Dup);
				val.Emit(OpCodes.Ldc_I4, 6);
				val.Emit(OpCodes.Ldloc, 14);
				val.Emit(OpCodes.Stelem_Ref);
				val = array[1];
				TypeReference val2 = default(TypeReference);
				val.FindPrev(ref array2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchNewarr(x, ref val2)
				});
				array2[0].Prev.OpCode = OpCodes.Ldc_I4_5;
				val.Emit(OpCodes.Dup);
				val.Emit(OpCodes.Ldc_I4, 4);
				val.Emit(OpCodes.Ldloc, 14);
				val.Emit(OpCodes.Stelem_Ref);
			}
			else
			{
				Debug.LogError((object)"skills");
			}
		}

		[HarmonyPatch(typeof(SyncOverlay), "OnReceived")]
		[HarmonyILManipulator]
		public static void KnifeOverlay(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)AccessTools.Method(typeof(GameObject), "AddComponent", Array.Empty<Type>(), new Type[1] { typeof(TemporaryOverlay) }))
			}))
			{
				val.Remove();
				val.Remove();
				val.EmitDelegate<Action<GameObject>>((Action<GameObject>)delegate(GameObject modelObject)
				{
					TemporaryOverlayInstance obj = TemporaryOverlayManager.AddOverlay(modelObject);
					obj.duration = 4f;
					obj.destroyComponentOnEnd = true;
					obj.originalMaterial = Assets.woundOverlayMat;
					obj.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 4f, 0f);
					obj.animateShaderAlpha = true;
					obj.AddToCharacterModel(modelObject.GetComponent<CharacterModel>());
				});
				ILLabel val2 = val.DefineLabel();
				val.Emit(OpCodes.Br, (object)val2);
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchStfld<TemporaryOverlay>(x, "animateShaderAlpha")
				});
				val.MarkLabel(val2);
			}
			else
			{
				Debug.LogError((object)"over");
			}
		}

		[HarmonyPatch(typeof(UseSyringe), "ApplyBuff")]
		[HarmonyILManipulator]
		public static void Syringe(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)AccessTools.Method(typeof(GameObject), "AddComponent", Array.Empty<Type>(), new Type[1] { typeof(TemporaryOverlay) }))
			}))
			{
				val.Remove();
				val.Remove();
				val.EmitDelegate<Action<GameObject>>((Action<GameObject>)delegate(GameObject modelObject)
				{
					TemporaryOverlayInstance obj = TemporaryOverlayManager.AddOverlay(modelObject);
					obj.duration = 12f;
					obj.animateShaderAlpha = true;
					obj.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
					obj.destroyComponentOnEnd = true;
					obj.originalMaterial = Assets.syringeDamageOverlayMat;
					obj.AddToCharacterModel(modelObject.GetComponent<CharacterModel>());
				});
				ILLabel val2 = val.DefineLabel();
				val.Emit(OpCodes.Br, (object)val2);
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<TemporaryOverlay>(x, "AddToCharacerModel")
				});
				val.MarkLabel(val2);
			}
			else
			{
				Debug.LogError((object)"over");
			}
		}

		[HarmonyPatch(typeof(UseSyringeLegacy), "ApplyBuff")]
		[HarmonyILManipulator]
		public static void SyringeLegacy(ILContext il)
		{
			//IL_0003: 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_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			ILCursor[] array = null;
			if (new ILCursor(il).TryFindNext(ref array, new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)AccessTools.Method(typeof(GameObject), "AddComponent", Array.Empty<Type>(), new Type[1] { typeof(TemporaryOverlay) })),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)AccessTools.Method(typeof(GameObject), "AddComponent", Array.Empty<Type>(), new Type[1] { typeof(TemporaryOverlay) })),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)AccessTools.Method(typeof(GameObject), "AddComponent", Array.Empty<Type>(), new Type[1] { typeof(TemporaryOverlay) }))
			}))
			{
				ILCursor val = array[0];
				val.Remove();
				val.Remove();
				val.EmitDelegate<Action<GameObject>>((Action<GameObject>)delegate(GameObject modelObject)
				{
					TemporaryOverlayInstance obj3 = TemporaryOverlayManager.AddOverlay(modelObject);
					obj3.duration = 12f;
					obj3.animateShaderAlpha = true;
					obj3.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
					obj3.destroyComponentOnEnd = true;
					obj3.originalMaterial = Assets.syringeDamageOverlayMat;
					obj3.AddToCharacterModel(modelObject.GetComponent<CharacterModel>());
				});
				ILLabel val2 = val.DefineLabel();
				val.Emit(OpCodes.Br, (object)val2);
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<TemporaryOverlay>(x, "AddToCharacerModel")
				});
				val.MarkLabel(val2);
				val = array[1];
				val.Remove();
				val.Remove();
				val.EmitDelegate<Action<GameObject>>((Action<GameObject>)delegate(GameObject modelObject)
				{
					TemporaryOverlayInstance obj2 = TemporaryOverlayManager.AddOverlay(modelObject);
					obj2.duration = 12f;
					obj2.animateShaderAlpha = true;
					obj2.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
					obj2.destroyComponentOnEnd = true;
					obj2.originalMaterial = Assets.syringeAttackSpeedOverlayMat;
					obj2.AddToCharacterModel(modelObject.GetComponent<CharacterModel>());
				});
				ILLabel val3 = val.DefineLabel();
				val.Emit(OpCodes.Br, (object)val3);
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<TemporaryOverlay>(x, "AddToCharacerModel")
				});
				val.MarkLabel(val3);
				val = array[2];
				val.Remove();
				val.Remove();
				val.EmitDelegate<Action<GameObject>>((Action<GameObject>)delegate(GameObject modelObject)
				{
					TemporaryOverlayInstance obj = TemporaryOverlayManager.AddOverlay(modelObject);
					obj.duration = 12f;
					obj.animateShaderAlpha = true;
					obj.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
					obj.destroyComponentOnEnd = true;
					obj.originalMaterial = Assets.syringeCritOverlayMat;
					obj.AddToCharacterModel(modelObject.GetComponent<CharacterModel>());
				});
				ILLabel val4 = val.DefineLabel();
				val.Emit(OpCodes.Br, (object)val4);
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<TemporaryOverlay>(x, "AddToCharacerModel")
				});
				val.MarkLabel(val4);
			}
			else
			{
				Debug.LogError((object)"over");
			}
		}

		[HarmonyPatch(typeof(UseSyringeScepter), "ApplyBuff")]
		[HarmonyILManipulator]
		public static void SyringeScepter(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)AccessTools.Method(typeof(GameObject), "AddComponent", Array.Empty<Type>(), new Type[1] { typeof(TemporaryOverlay) }))
			}))
			{
				val.Remove();
				val.Remove();
				val.EmitDelegate<Action<GameObject>>((Action<GameObject>)delegate(GameObject modelObject)
				{
					TemporaryOverlayInstance obj = TemporaryOverlayManager.AddOverlay(modelObject);
					obj.duration = 12f;
					obj.animateShaderAlpha = true;
					obj.alphaCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
					obj.destroyComponentOnEnd = true;
					obj.originalMaterial = Assets.syringeScepterOverlayMat;
					obj.AddToCharacterModel(modelObject.GetComponent<CharacterModel>());
				});
				ILLabel val2 = val.DefineLabel();
				val.Emit(OpCodes.Br, (object)val2);
				val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
				{
					(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<TemporaryOverlay>(x, "AddToCharacerModel")
				});
				val.MarkLabel(val2);
			}
			else
			{
				Debug.LogError((object)"over");
			}
		}
	}
}