using System;
using System.Collections;
using System.Collections.Generic;
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.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Steamworks;
using Steamworks.Data;
using Unity.Netcode;
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("LethalClips")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.0.4.0")]
[assembly: AssemblyInformationalVersion("0.0.4+a4de4cc3b2a7822f66b037f0a0e55d4ba420337c")]
[assembly: AssemblyProduct("Lethal Clips")]
[assembly: AssemblyTitle("LethalClips")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.4.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 LethalClips
{
	public static class Config
	{
		public class ConfigGroup
		{
			[CompilerGenerated]
			private ConfigFile <config>P;

			[CompilerGenerated]
			private string <group>P;

			public ConfigGroup(ConfigFile config, string group)
			{
				<config>P = config;
				<group>P = group;
				base..ctor();
			}

			public ConfigEntry<T> Bind<T>(string key, T defaultValue, string description, AcceptableValueBase acceptableValues = null, params object[] tags)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Expected O, but got Unknown
				return <config>P.Bind<T>(<group>P, key, defaultValue, new ConfigDescription(description, acceptableValues, tags));
			}
		}

		public static class General
		{
			public static ConfigEntry<bool> Enabled { get; private set; }

			public static void Initialize(ConfigGroup config)
			{
				Enabled = config.Bind("Enabled", true, "Whether the mod should be loaded on game startup", null);
			}
		}

		public static class Clips
		{
			public static ConfigEntry<bool> Deaths { get; private set; }

			public static ConfigEntry<bool> Apparatus { get; private set; }

			public static ConfigEntry<bool> Teleporter { get; private set; }

			public static ConfigEntry<bool> Rounds { get; private set; }

			public static void Initialize(ConfigGroup config)
			{
				Deaths = config.Bind("Clip Deaths", true, "Create clip markers for player deaths", null);
				Apparatus = config.Bind("Clip Apparatus", true, "Create clip markers when someone takes the apparatus", null);
				Teleporter = config.Bind("Clip Teleporter", true, "Create clips markers when you are teleported by one of the teleporters", null);
				Rounds = config.Bind("Clip Round", true, "Create clip markers when the round begins and ends", null);
			}
		}

		public static void Initialize(ConfigFile config)
		{
			General.Initialize(new ConfigGroup(config, "General"));
			Clips.Initialize(new ConfigGroup(config, "Clips"));
		}
	}
	public enum ExtendedCauseOfDeath
	{
		Killed,
		Bludgeoned,
		SPLAT,
		Exploded,
		Strangled,
		Suffocated,
		Mauled,
		Shot,
		Crushed,
		Drowned,
		Abandoned,
		Electrocuted,
		Kicked,
		Incinerated,
		Stabbed,
		Sliced,
		Crashed,
		Snipped,
		Devoured,
		Springed,
		Died,
		Disintegrated,
		Infected,
		Embarrassing
	}
	public static class Player
	{
		public static PlayerControllerB Local => GameNetworkManager.Instance.localPlayerController;

		public static PlayerControllerB FromID(int id)
		{
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			if (0 > id || id >= allPlayerScripts.Length)
			{
				return null;
			}
			return allPlayerScripts[id];
		}

		public static bool IsLocal(int playerId)
		{
			return IsLocal(FromID(playerId));
		}

		public static bool IsLocal(PlayerControllerB player)
		{
			return (Object)(object)player == (Object)(object)Local;
		}
	}
	[BepInPlugin("com.lalabuff.lethal.lethalclips", "LethalClips", "0.0.4")]
	public class Plugin : BaseUnityPlugin
	{
		private const string GUID = "com.lalabuff.lethal.lethalclips";

		private const string NAME = "LethalClips";

		private const string VERSION = "0.0.4";

		internal static ManualLogSource Log;

		internal void Awake()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			Config.Initialize(((BaseUnityPlugin)this).Config);
			if (!Config.General.Enabled.Value)
			{
				Log.LogWarning((object)"Mod is disabled. No patching will occur. To enable the mod, edit the configuration file and restart the game.");
				return;
			}
			Harmony val = new Harmony("com.lalabuff.lethal.lethalclips");
			val.PatchAll();
			foreach (MethodBase patchedMethod in val.GetPatchedMethods())
			{
				Log.LogInfo((object)$"Patched method {patchedMethod}.");
			}
			Log.LogInfo((object)"Successfully loaded LethalClips (com.lalabuff.lethal.lethalclips) v0.0.4!");
		}
	}
	public abstract class State<K, V> where V : State<K, V>, new()
	{
		private static readonly Dictionary<K, V> states = new Dictionary<K, V>();

		public K Instance { get; private set; }

		public static V Of(K obj)
		{
			if (!states.TryGetValue(obj, out var value))
			{
				V val2 = (states[obj] = new V());
				value = val2;
				value.Instance = obj;
			}
			return value;
		}

		public static IEnumerable<(K, V)> All()
		{
			foreach (KeyValuePair<K, V> state in states)
			{
				yield return (state.Key, state.Value);
			}
		}
	}
	public static class StateExtensions
	{
		public static V GetState<K, V>(this GameObject obj) where K : Component where V : State<K, V>, new()
		{
			return State<K, V>.Of(obj.GetComponent<K>());
		}

		public static bool TryGetState<K, V>(this GameObject obj, out V state) where K : Component where V : State<K, V>, new()
		{
			K obj2 = default(K);
			if (obj.TryGetComponent<K>(ref obj2))
			{
				state = State<K, V>.Of(obj2);
				return true;
			}
			state = null;
			return false;
		}

		public static V GetState<K, V>(this Component obj) where K : Component where V : State<K, V>, new()
		{
			return obj.gameObject.GetState<K, V>();
		}

		public static bool TryGetState<K, V>(this Component obj, out V state) where K : Component where V : State<K, V>, new()
		{
			return obj.gameObject.TryGetState<K, V>(out state);
		}
	}
	public static class Steam
	{
		public enum Icon
		{
			Death,
			Caution,
			Transfer,
			Flag,
			Completed
		}

		public static string IconToString(Icon icon)
		{
			return icon switch
			{
				Icon.Death => "steam_death", 
				Icon.Caution => "steam_caution", 
				Icon.Transfer => "steam_transfer", 
				Icon.Flag => "steam_flag", 
				Icon.Completed => "steam_completed", 
				_ => "steam_marker", 
			};
		}

		public static TimelineEventHandle? AddEvent(string title, string description, Icon icon, uint priority = 0u, float offset = 0f, TimelineEventClipPriority possibleClip = 2)
		{
			//IL_000b: 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_0012: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				TimelineEventHandle val = SteamTimeline.AddInstantaneousTimelineEvent(title, description, IconToString(icon), priority, offset, possibleClip);
				Plugin.Log.LogInfo((object)$"Added timeline event {val}.");
				return val;
			}
			catch (Exception arg)
			{
				Plugin.Log.LogError((object)$"Failed to add timeline event '{title}': {arg}");
				return null;
			}
		}
	}
}
namespace LethalClips.Patches
{
	[HarmonyPatch]
	public static class AnimationPatch
	{
		[HarmonyPatch(typeof(FlowermanAI), "killAnimation")]
		[HarmonyPrefix]
		public static void Bracken(FlowermanAI __instance)
		{
			State<PlayerControllerB, PlayerState>.Of(((EnemyAI)__instance).inSpecialAnimationWithPlayer).Kill(ExtendedCauseOfDeath.Strangled, "Bracken", -1f);
		}

		[HarmonyPatch(typeof(MouthDogAI), "KillPlayer")]
		[HarmonyPrefix]
		public static void EyelessDog(int playerId)
		{
			State<PlayerControllerB, PlayerState>.Of(Player.FromID(playerId)).Kill(ExtendedCauseOfDeath.Mauled, "Eyeless Dog", -1f);
		}

		[HarmonyPatch(typeof(ForestGiantAI), "EatPlayerAnimation")]
		[HarmonyPrefix]
		public static void ForestKeeper(PlayerControllerB playerBeingEaten)
		{
			State<PlayerControllerB, PlayerState>.Of(playerBeingEaten).Kill(ExtendedCauseOfDeath.Devoured, "Forest Keeper", 6f);
		}

		[HarmonyPatch(typeof(JesterAI), "killPlayerAnimation")]
		[HarmonyPrefix]
		public static void Jester(int playerId)
		{
			State<PlayerControllerB, PlayerState>.Of(Player.FromID(playerId)).Kill(ExtendedCauseOfDeath.Mauled, "Jester", -1f);
		}

		[HarmonyPatch(typeof(MaskedPlayerEnemy), "killAnimation")]
		[HarmonyPrefix]
		public static void Masked(MaskedPlayerEnemy __instance)
		{
			State<PlayerControllerB, PlayerState>.Of(((EnemyAI)__instance).inSpecialAnimationWithPlayer).Kill(ExtendedCauseOfDeath.Infected, __instance.mimickingPlayer?.playerUsername ?? "Masked", 5f);
		}

		[HarmonyPatch(typeof(RadMechAI), "TorchPlayerAnimation")]
		[HarmonyPrefix]
		public static void OldBird(RadMechAI __instance)
		{
			State<PlayerControllerB, PlayerState>.Of(((EnemyAI)__instance).inSpecialAnimationWithPlayer).Kill(ExtendedCauseOfDeath.Incinerated, "Old Bird", 7f);
		}
	}
	[HarmonyPatch(typeof(LungProp))]
	public class ApparatusPatch
	{
		[HarmonyPatch("DisconnectFromMachinery")]
		[HarmonyPostfix]
		public static void DisconnectFromMachinery()
		{
			if (Config.Clips.Apparatus.Value)
			{
				Steam.AddEvent("WARNING!", "Someone took the apparatus", Steam.Icon.Caution, 0u, 0f, (TimelineEventClipPriority)2);
			}
		}
	}
	[HarmonyPatch(typeof(EnemyAI))]
	public static class DamagePatch
	{
		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyPrefix]
		public static void OnCollideWithPlayer(EnemyAI __instance, Collider other)
		{
			bool flag = __instance is DressGirlAI;
			if (Object.op_Implicit((Object)(object)__instance.MeetsStandardPlayerCollisionConditions(other, false, flag)))
			{
				(ExtendedCauseOfDeath, string, int) tuple = ((__instance is ClaySurgeonAI) ? (ExtendedCauseOfDeath.Snipped, "Barber", -1) : ((__instance is RedLocustBees) ? (ExtendedCauseOfDeath.Electrocuted, "Circuit Bees", 10) : ((__instance is ButlerEnemyAI) ? (ExtendedCauseOfDeath.Stabbed, "Butler", 10) : ((__instance is SpringManAI) ? (ExtendedCauseOfDeath.Springed, "Coil-Head", 90) : ((__instance is BushWolfEnemy) ? (ExtendedCauseOfDeath.Mauled, "Kidnapper Fox", -1) : ((__instance is DressGirlAI) ? (ExtendedCauseOfDeath.Died, "", -1) : ((__instance is BaboonBirdAI) ? (ExtendedCauseOfDeath.Stabbed, "Baboon Hawk", 20) : ((__instance is ButlerBeesEnemyAI) ? (ExtendedCauseOfDeath.Stabbed, "Mask Hornets", 10) : ((__instance is PufferAI) ? (ExtendedCauseOfDeath.Embarrassing, "", 20) : ((__instance is HoarderBugAI) ? (ExtendedCauseOfDeath.Mauled, "Hoarding Bug", 30) : ((__instance is CaveDwellerAI) ? (ExtendedCauseOfDeath.Mauled, "Maneater", -1) : ((__instance is NutcrackerEnemyAI) ? (ExtendedCauseOfDeath.Kicked, "Nutcracker", -1) : ((__instance is BlobAI) ? (ExtendedCauseOfDeath.Disintegrated, "Hydrogere", 35) : ((__instance is SandSpiderAI) ? (ExtendedCauseOfDeath.Mauled, "Bunker Spider", 90) : ((__instance is CrawlerAI) ? (ExtendedCauseOfDeath.Mauled, "Thumper", 40) : ((!(__instance is SandWormAI)) ? default((ExtendedCauseOfDeath, string, int)) : (ExtendedCauseOfDeath.Devoured, "Earth Leviathan", -1)))))))))))))))));
				(ExtendedCauseOfDeath, string, int) tuple2 = tuple;
				ExtendedCauseOfDeath item = tuple2.Item1;
				string item2 = tuple2.Item2;
				int item3 = tuple2.Item3;
				PlayerState local = PlayerState.Local;
				if (item3 == -1)
				{
					local.Kill(item, item2);
				}
				else
				{
					local.Damage(item, item2, item3);
				}
			}
		}
	}
	[HarmonyPatch(typeof(CentipedeAI))]
	public class FleaPatch
	{
		[HarmonyPatch("DamagePlayerOnIntervals")]
		[HarmonyPrefix]
		public static void DamagePlayerOnIntervals(CentipedeAI __instance)
		{
			if (__instance.damagePlayerInterval <= 0f && !__instance.inDroppingOffPlayerAnim && ((EnemyAI)__instance).stunNormalizedTimer <= 0f && (StartOfRound.Instance.connectedPlayersAmount > 0 || Player.Local.health > 15 || __instance.singlePlayerSecondChanceGiven))
			{
				PlayerState.Local.Damage(ExtendedCauseOfDeath.Suffocated, "Snare Flea", 10f);
			}
		}
	}
	[HarmonyPatch(typeof(ForestGiantAI))]
	public class GiantPatch
	{
		[HarmonyPatch("AnimationEventA")]
		[HarmonyPrefix]
		public static void AnimationEventA(ForestGiantAI __instance)
		{
			//IL_0006: 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)
			RaycastHit[] array = Physics.SphereCastAll(__instance.deathFallPosition.position, 2.7f, __instance.deathFallPosition.forward, 3.9f, StartOfRound.Instance.playersMask, (QueryTriggerInteraction)1);
			for (int i = 0; i < array.Length; i++)
			{
				((Component)(object)((RaycastHit)(ref array[i])).transform).GetState<PlayerControllerB, PlayerState>().Damage(ExtendedCauseOfDeath.Crushed, "Forest Keeper", 30f);
			}
		}
	}
	public class LandmineState : State<Landmine, LandmineState>
	{
		public PlayerControllerB Detonator { get; set; }

		public string DetonatorName
		{
			get
			{
				if (Object.op_Implicit((Object)(object)Detonator) && !((Object)(object)Detonator == (Object)(object)Player.Local))
				{
					return Detonator.playerUsername;
				}
				return "Landmine";
			}
		}

		public static void SpawnExplosion(Vector3 explosionPosition, float killRange, float damageRange, int nonLethalDamage, string source)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogWarning((object)"kabooming");
			Collider[] array = Physics.OverlapSphere(explosionPosition, damageRange, 2621448, (QueryTriggerInteraction)2);
			RaycastHit val = default(RaycastHit);
			for (int i = 0; i < array.Length; i++)
			{
				Plugin.Log.LogWarning((object)"hit");
				GameObject gameObject = ((Component)array[i]).gameObject;
				float num = Vector3.Distance(explosionPosition, gameObject.transform.position);
				if ((!Physics.Linecast(explosionPosition, gameObject.transform.position + Vector3.up * 0.3f, ref val, 1073742080, (QueryTriggerInteraction)1) || (((Component)((RaycastHit)(ref val)).collider).gameObject.layer != 30 && !(num > 4f))) && gameObject.layer == 3)
				{
					Plugin.Log.LogWarning((object)$"found object {gameObject}");
					PlayerState state = gameObject.GetState<PlayerControllerB, PlayerState>();
					Plugin.Log.LogWarning((object)$"player {state}");
					if (num < killRange)
					{
						state.Kill(ExtendedCauseOfDeath.Exploded, source);
					}
					else if (num < damageRange)
					{
						state.Damage(ExtendedCauseOfDeath.Exploded, source, nonLethalDamage);
					}
					break;
				}
			}
		}

		public void SpawnExplosion(Vector3 explosionPosition, float killRange, float damageRange, int nonLethalDamage)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			SpawnExplosion(explosionPosition, killRange, damageRange, nonLethalDamage, DetonatorName);
		}
	}
	[HarmonyPatch(typeof(Landmine))]
	public class LandminePatch
	{
		[HarmonyPatch("OnTriggerExit")]
		[HarmonyPrefix]
		public static void OnTriggerExit(Landmine __instance, Collider other)
		{
			if (__instance.hasExploded || !__instance.mineActivated)
			{
				return;
			}
			Transform val = ((Component)other).transform;
			PlayerControllerB detonator = default(PlayerControllerB);
			while (Object.op_Implicit((Object)(object)val))
			{
				if (((Component)val).TryGetComponent<PlayerControllerB>(ref detonator))
				{
					State<Landmine, LandmineState>.Of(__instance).Detonator = detonator;
					break;
				}
				val = val.parent;
			}
		}

		[HarmonyPatch("Detonate")]
		[HarmonyPrefix]
		public static void Detonate(Landmine __instance)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			State<Landmine, LandmineState>.Of(__instance).SpawnExplosion(((Component)__instance).transform.position + Vector3.up, 5.7f, 6f, 50);
		}
	}
	[HarmonyPatch(typeof(RadMechAI))]
	public class MechPatch
	{
		[HarmonyPatch("Stomp")]
		[HarmonyPrefix]
		public static void Stomp(Transform stompTransform, float radius)
		{
			//IL_000a: 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)
			double num = Vector3.Distance(((Component)Player.Local).transform.position, stompTransform.position);
			if (num < (double)radius)
			{
				if (num < (double)radius * 0.175)
				{
					PlayerState.Local.Damage(ExtendedCauseOfDeath.Crushed, "Old Bird", 70f);
				}
				else if (num < (double)(radius * 0.5f))
				{
					PlayerState.Local.Damage(ExtendedCauseOfDeath.Crushed, "Old Bird", 30f);
				}
			}
		}

		[HarmonyPatch("SetExplosion")]
		[HarmonyPrefix]
		public static void SetExplosion(Vector3 explosionPosition, Vector3 forwardRotation)
		{
			//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_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)
			LandmineState.SpawnExplosion(explosionPosition - forwardRotation * 0.1f, 1f, 7f, 30, "Old Bird");
		}
	}
	public class PlayerState : State<PlayerControllerB, PlayerState>
	{
		public static PlayerState Local => State<PlayerControllerB, PlayerState>.Of(Player.Local);

		public ExtendedCauseOfDeath CauseOfDeath { get; private set; }

		public string SourceOfDeath { get; private set; }

		public float DeathTimeout { get; private set; }

		public string Message
		{
			get
			{
				string text = Enum.GetName(typeof(ExtendedCauseOfDeath), CauseOfDeath) ?? "Killed";
				if (!string.IsNullOrEmpty(SourceOfDeath))
				{
					text = text + " by " + SourceOfDeath;
				}
				return text;
			}
		}

		public void Kill(ExtendedCauseOfDeath cause, string source, float timeout = 0.1f)
		{
			if (!(DeathTimeout < 0f))
			{
				CauseOfDeath = cause;
				SourceOfDeath = source;
				if (timeout >= 0f)
				{
					DeathTimeout = Time.time + timeout;
				}
				else
				{
					DeathTimeout = -1f;
				}
			}
		}

		public void Damage(ExtendedCauseOfDeath cause, string source, float damage)
		{
			if ((float)base.Instance.health <= damage && (damage >= 50f || base.Instance.criticallyInjured))
			{
				Kill(cause, source);
			}
		}

		public void TriggerDeathEvent(CauseOfDeath causeOfDeath)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected I4, but got Unknown
			if (0f <= DeathTimeout && DeathTimeout < Time.time)
			{
				CauseOfDeath = (ExtendedCauseOfDeath)causeOfDeath;
				SourceOfDeath = "";
			}
			DeathTimeout = 0f;
			if (Config.Clips.Deaths.Value)
			{
				Steam.AddEvent("You died!", Message, Steam.Icon.Death, 96u, 0f, (TimelineEventClipPriority)2);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	public static class PlayerPatch
	{
		[HarmonyPatch("KillPlayer")]
		[HarmonyPrefix]
		public static void KillPlayer(PlayerControllerB __instance, CauseOfDeath causeOfDeath)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)__instance).IsOwner && !__instance.isPlayerDead && __instance.AllowPlayerDeath())
			{
				State<PlayerControllerB, PlayerState>.Of(__instance).TriggerDeathEvent(causeOfDeath);
			}
		}
	}
	[HarmonyPatch(typeof(ShotgunItem))]
	public class ShotgunPatch
	{
		[HarmonyPatch("ShootGun")]
		[HarmonyPrefix]
		public static void ShootGun(ShotgunItem __instance, Vector3 shotgunPosition, Vector3 shotgunForward)
		{
			//IL_0061: 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)
			//IL_0086: 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_0091: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			string source = (((GrabbableObject)__instance).isHeldByEnemy ? "Nutcracker" : ((!((GrabbableObject)__instance).isHeld) ? "Accident" : (((GrabbableObject)__instance).playerHeldBy?.playerUsername ?? "Player")));
			bool num = ((GrabbableObject)__instance).isHeld && (Object)(object)((GrabbableObject)__instance).playerHeldBy == (Object)(object)Player.Local;
			float num2 = Vector3.Distance(((Component)Player.Local).transform.position, ((Component)__instance.shotgunRayPoint).transform.position);
			Vector3 val = Player.Local.playerCollider.ClosestPoint(shotgunPosition);
			bool num3 = !num & !Physics.Linecast(shotgunPosition, val, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1) & (Vector3.Angle(shotgunForward, val - shotgunPosition) < 30f);
			int num4 = 0;
			if (num2 < 15f)
			{
				num4 = 100;
			}
			else if (num2 < 23f)
			{
				num4 = 40;
			}
			else if (num2 < 30f)
			{
				num4 = 20;
			}
			if (num3)
			{
				PlayerState.Local.Damage(ExtendedCauseOfDeath.Shot, source, num4);
			}
		}
	}
	[HarmonyPatch(typeof(SpikeRoofTrap))]
	public static class SpikePatch
	{
		[HarmonyPatch("OnTriggerStay")]
		[HarmonyPrefix]
		public static void OnTriggerStay(SpikeRoofTrap __instance, Collider other)
		{
			if (__instance.trapActive && __instance.slammingDown && !(Time.realtimeSinceStartup - __instance.timeSinceMovingUp < 0.75f) && ((Component)(object)other).TryGetState<PlayerControllerB, PlayerState>(out PlayerState state) && !state.Instance.isPlayerDead)
			{
				state.Kill(ExtendedCauseOfDeath.Crushed, "Spike Trap");
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class StartOfRoundPatch
	{
		[HarmonyPatch("openingDoorsSequence")]
		[HarmonyPrefix]
		public static void OpeningDoorsSequence()
		{
			if (Config.Clips.Rounds.Value)
			{
				Steam.AddEvent("Round start", "The ship has landed", Steam.Icon.Flag, 0u, 0f, (TimelineEventClipPriority)2);
			}
		}

		[HarmonyPatch("ShipHasLeft")]
		[HarmonyPrefix]
		public static void ShipHasLeft()
		{
			if (Config.Clips.Rounds.Value)
			{
				Steam.AddEvent("Round end", "The ship has left", Steam.Icon.Completed, 0u, 0f, (TimelineEventClipPriority)2);
			}
		}
	}
	[HarmonyPatch(typeof(ShipTeleporter))]
	public class TeleporterPatch
	{
		[HarmonyPatch("beamUpPlayer")]
		[HarmonyPostfix]
		public static void BeamUpPlayer(ref IEnumerator __result)
		{
			IEnumerator original = __result;
			__result = Wrapper();
			IEnumerator Wrapper()
			{
				PlayerControllerB player = StartOfRound.Instance.mapScreen.targetedPlayer;
				yield return original;
				if (Config.Clips.Teleporter.Value && (Object)(object)player == (Object)(object)Player.Local)
				{
					string description = (player.isPlayerDead ? "Yoink" : "Sav") + "ed by the teleporter";
					Steam.AddEvent("Teleported", description, Steam.Icon.Transfer, 0u, 0f, (TimelineEventClipPriority)2);
				}
			}
		}

		[HarmonyPatch("TeleportPlayerOutWithInverseTeleporter")]
		[HarmonyPostfix]
		public static void TeleportPlayerOutWithInverseTeleporter(int playerObj)
		{
			if (Config.Clips.Teleporter.Value && (Object)(object)Player.FromID(playerObj) == (Object)(object)Player.Local)
			{
				Steam.AddEvent("Teleported", "Inverse teleported into the facility", Steam.Icon.Transfer, 0u, 0f, (TimelineEventClipPriority)2);
			}
		}
	}
	[HarmonyPatch(typeof(Turret))]
	public static class TurretPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		public static void Update(Turret __instance)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			if (__instance.turretActive && ((int)__instance.turretMode == 2 || ((int)__instance.turretMode == 3 && !__instance.enteringBerserkMode)) && __instance.turretInterval >= 0.21f && (Object)(object)__instance.CheckForPlayersInLineOfSight(3f, false) == (Object)(object)Player.Local)
			{
				PlayerState.Local.Damage(ExtendedCauseOfDeath.Shot, "Turret", 50f);
			}
		}
	}
}