using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using OPJosMod.OneHitShovel.CustomRpc;
using OPJosMod.OneHitShovel.Patches;
using OPJosMod.OneHitShovel.Utils;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("OPJosMod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OPJosMod")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("70095872-b952-4e27-bbc4-3d70d0238f39")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace OPJosMod
{
	public static class ConfigVariables
	{
		public static bool syncDeathAnimations;
	}
}
namespace OPJosMod.OneHitShovel
{
	public static class Constants
	{
		public static List<string> humanoidNames = new List<string> { "SpringManModel", "DressGirlModel", "MeshContainer", "SpringMan(Clone)", "DressGirl(Clone)", "JesterEnemy(Clone)" };

		public static string[] fourLeggedNames = new string[2] { "PufferModel", "PufferEnemy(Clone)" };

		public static string[] dieInPlaceNames = new string[3] { "Bone.", "Bone", "SandWorm(Clone)" };

		public static string[] slimeNames = new string[10] { "BoneEast", "BoneNorth", "BoneSouth", "BoneWest", "BoneNorthWest", "BoneNorthEast", "BoneSouthEast", "BoneSouthWest", "Center", "Blob(Clone)" };

		public static string[] mechNames = new string[2] { "ClawTrigger", "RadMechEnemy(Clone)" };
	}
	public static class CustomEnemyDeaths
	{
		private static ManualLogSource mls;

		public static void SetLogSource(ManualLogSource logSource)
		{
			mls = logSource;
		}

		public static void killHumanoid(GameObject gameObject)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_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_00cb: Unknown result type (might be due to invalid IL or missing references)
			mls.LogMessage((object)("try to kill " + ((Object)gameObject).name));
			gameObject.transform.rotation = Quaternion.Euler(-90f, 0f, 90f);
			Renderer component = gameObject.GetComponent<Renderer>();
			float num;
			if (!((Object)(object)component != (Object)null))
			{
				num = 0.1f;
			}
			else
			{
				Bounds bounds = component.bounds;
				num = ((Bounds)(ref bounds)).size.x * 0.1f;
			}
			float num2 = num;
			Transform transform = gameObject.transform;
			transform.position += new Vector3(0f, num2, 0f);
			Collider[] componentsInChildren = gameObject.GetComponentsInChildren<Collider>();
			Collider[] array = componentsInChildren;
			foreach (Collider val in array)
			{
				val.enabled = false;
			}
			EnemyAI val2 = findClosestEnemyAI(gameObject.transform.position);
			if ((Object)(object)val2 != (Object)null)
			{
				mls.LogMessage((object)"enemy ai isn't null");
				val2.isEnemyDead = true;
				((Behaviour)val2.creatureAnimator).enabled = false;
				stopAllSounds(val2);
			}
			else
			{
				mls.LogMessage((object)"enemy ai is null");
			}
		}

		public static IEnumerator KillMech(Vector3 hitLocation, bool updateOnServer = false)
		{
			//IL_0007: 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)
			EnemyAI enemyAI = findClosestEnemyAI(hitLocation);
			try
			{
				mls.LogMessage((object)"trying to kill mech");
				if (enemyAI is RadMechAI)
				{
					RadMechAI radMech = (RadMechAI)enemyAI;
					((MonoBehaviour)radMech).StopAllCoroutines();
					killHumanoid(((Component)radMech).gameObject);
					if (updateOnServer)
					{
						updateLocationOnServer(((Component)radMech).gameObject);
					}
					radMech.DisableSpotlight();
					radMech.DisableBlowtorch();
					radMech.DisableThrusterSmoke();
					((EnemyAI)radMech).enemyHP = 0;
					((Behaviour)radMech.engineSFX).enabled = false;
					radMech.chargeForwardAudio.volume = 0f;
					radMech.engineSFX.volume = 0f;
					radMech.flyingDistantAudio.volume = 0f;
					radMech.spotlightOnAudio.volume = 0f;
					radMech.LocalLRADAudio.volume = 0f;
					radMech.LocalLRADAudio2.volume = 0f;
					radMech.blowtorchAudio.volume = 0f;
				}
			}
			catch
			{
			}
			yield return (object)new WaitForSeconds(0.2f);
			killHumanoid(((Component)enemyAI).gameObject);
		}

		public static void killInPlace(GameObject gameObject)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			mls.LogMessage((object)("try to kill " + ((Object)gameObject).name));
			Collider[] componentsInChildren = gameObject.GetComponentsInChildren<Collider>();
			Collider[] array = componentsInChildren;
			foreach (Collider val in array)
			{
				val.enabled = false;
			}
			EnemyAI val2 = findClosestEnemyAI(gameObject.transform.position);
			if ((Object)(object)val2 != (Object)null)
			{
				mls.LogMessage((object)"enemy ai isn't null");
				val2.isEnemyDead = true;
				((Behaviour)val2.creatureAnimator).enabled = false;
				stopAllSounds(val2);
			}
			else
			{
				mls.LogMessage((object)"enemy ai is null");
			}
		}

		public static void killFourLegged(GameObject gameObject)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_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_00cb: Unknown result type (might be due to invalid IL or missing references)
			mls.LogMessage((object)("try to kill " + ((Object)gameObject).name));
			gameObject.transform.rotation = Quaternion.Euler(180f, 0f, 0f);
			Renderer component = gameObject.GetComponent<Renderer>();
			float num;
			if (!((Object)(object)component != (Object)null))
			{
				num = 1f;
			}
			else
			{
				Bounds bounds = component.bounds;
				num = ((Bounds)(ref bounds)).size.y * 0.1f;
			}
			float num2 = num;
			Transform transform = gameObject.transform;
			transform.position += new Vector3(0f, num2, 0f);
			Collider[] componentsInChildren = gameObject.GetComponentsInChildren<Collider>();
			Collider[] array = componentsInChildren;
			foreach (Collider val in array)
			{
				val.enabled = false;
			}
			EnemyAI val2 = findClosestEnemyAI(gameObject.transform.position);
			if ((Object)(object)val2 != (Object)null)
			{
				mls.LogMessage((object)"enemy ai isn't null");
				val2.isEnemyDead = true;
				((Behaviour)val2.creatureAnimator).enabled = false;
				stopAllSounds(val2);
			}
			else
			{
				mls.LogMessage((object)"enemy ai is null");
			}
		}

		public static void killSlime(GameObject gameObject)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			mls.LogMessage((object)("try to kill " + ((Object)gameObject).name));
			EnemyAI val = findClosestEnemyAI(gameObject.transform.position);
			if ((Object)(object)val != (Object)null)
			{
				mls.LogMessage((object)"enemy ai isn't null");
				val.isEnemyDead = true;
				((Behaviour)val.creatureAnimator).enabled = false;
			}
			else
			{
				mls.LogMessage((object)"enemy ai is null");
			}
			Object.Destroy((Object)(object)val);
			stopAllSounds(val);
			string[] slimeNames = Constants.slimeNames;
			foreach (string name in slimeNames)
			{
				destroySlimePart(gameObject, name);
			}
		}

		public static void updateLocationOnServer(GameObject gameObject)
		{
			//IL_0007: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI val = findClosestEnemyAI(gameObject.transform.position);
			if ((Object)(object)val != (Object)null)
			{
				val.KillEnemyServerRpc(false);
			}
			else
			{
				mls.LogMessage((object)"no enemy to kill");
			}
			if (ConfigVariables.syncDeathAnimations)
			{
				string code = MessageTaskUtil.GetCode(MessageTasks.EnemyDied);
				Vector3 position = gameObject.transform.position;
				string message = code + ((object)(Vector3)(ref position)).ToString();
				RpcMessage message2 = new RpcMessage(message, (int)StartOfRound.Instance.localPlayerController.playerClientId, MessageCodes.Request);
				RpcMessageHandler.SendRpcMessage(message2);
			}
			else
			{
				val.KillEnemyServerRpc(true);
			}
		}

		private static void stopAllSounds(EnemyAI enemy)
		{
			AudioSource[] componentsInChildren = ((Component)enemy).GetComponentsInChildren<AudioSource>();
			AudioSource[] array = componentsInChildren;
			foreach (AudioSource val in array)
			{
				val.Stop();
			}
		}

		private static void destroySlimePart(GameObject gameObject, string name)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			GameObject[] array = Object.FindObjectsOfType<GameObject>();
			GameObject val = null;
			float num = float.PositiveInfinity;
			GameObject[] array2 = array;
			foreach (GameObject val2 in array2)
			{
				if (((Object)val2).name == name)
				{
					float num2 = Vector3.Distance(gameObject.transform.position, val2.transform.position);
					if (num2 < num && num2 < 15f)
					{
						num = num2;
						val = val2;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				mls.LogMessage((object)("Closest Enemy with name '" + name + "' found: " + ((Object)val).name));
			}
			else
			{
				mls.LogMessage((object)("No Enemy with name '" + name + "' found in the scene."));
			}
			Object.Destroy((Object)(object)val);
		}

		public static EnemyAI findClosestEnemyAI(Vector3 location)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI val = null;
			EnemyAI[] array = Object.FindObjectsOfType<EnemyAI>();
			float num = float.PositiveInfinity;
			EnemyAI[] array2 = array;
			foreach (EnemyAI val2 in array2)
			{
				float num2 = Vector3.Distance(location, ((Component)val2).transform.position);
				if (num2 < num)
				{
					num = num2;
					val = val2;
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				mls.LogMessage((object)("Closest EnemyAI found: " + ((Object)val).name));
			}
			else
			{
				mls.LogError((object)"No EnemyAI found in the scene.");
			}
			return val;
		}

		public static void KillAnyEnemy(EnemyAI enemy)
		{
			mls.LogMessage((object)("enemy died " + ((Object)enemy).name));
			GameObject gameObject = ((Component)enemy).gameObject;
			KillGameObjectEnemy(gameObject);
		}

		public static void KillGameObjectEnemy(GameObject gameObject)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)gameObject != (Object)null && ((Object)gameObject).name != "Player")
			{
				mls.LogMessage((object)("kill game object with name: " + ((Object)gameObject).name));
				if (Constants.humanoidNames.Contains(((Object)gameObject).name))
				{
					killHumanoid(gameObject);
				}
				if (Constants.fourLeggedNames.Contains(((Object)gameObject).name))
				{
					killFourLegged(gameObject);
				}
				if (Constants.slimeNames.Contains(((Object)gameObject).name))
				{
					killSlime(gameObject);
				}
				if (Constants.mechNames.Contains(((Object)gameObject).name))
				{
					((MonoBehaviour)StartOfRound.Instance.localPlayerController).StartCoroutine(KillMech(gameObject.transform.position));
				}
				if (((Object)gameObject).name == null)
				{
					return;
				}
				int num = ((Object)gameObject).name.LastIndexOf('.');
				if (num != -1)
				{
					string value = ((Object)gameObject).name.Substring(0, num + 1);
					if (Constants.dieInPlaceNames.Contains(value))
					{
						killInPlace(gameObject);
					}
				}
			}
			else
			{
				mls.LogError((object)"game object was null");
			}
		}
	}
	public static class GeneralUtil
	{
		public static Vector3 StringToVector3(string s)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			string[] array = s.Trim('(', ')').Split(new char[1] { ',' });
			float num = float.Parse(array[0]);
			float num2 = float.Parse(array[1]);
			float num3 = float.Parse(array[2]);
			return new Vector3(num, num2, num3);
		}

		public static int GetGameVersion()
		{
			try
			{
				return GameNetworkManager.Instance.gameVersionNum;
			}
			catch
			{
			}
			return 0;
		}
	}
	public static class GlobalVariables
	{
		public static bool ModActivated;
	}
	[BepInPlugin("OpJosMod.OneHitShovel", "OneHitShovel", "1.5.1")]
	public class OpJosMod : BaseUnityPlugin
	{
		private const string modGUID = "OpJosMod.OneHitShovel";

		private const string modName = "OneHitShovel";

		private const string modVersion = "1.5.1";

		private readonly Harmony harmony = new Harmony("OpJosMod.OneHitShovel");

		private static OpJosMod Instance;

		internal ManualLogSource mls;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = Logger.CreateLogSource("OpJosMod.OneHitShovel");
			setupConfig();
			PatchesForRPC.SetLogSource(mls);
			RpcMessageHandler.SetLogSource(mls);
			CompleteRecievedTasks.SetLogSource(mls);
			ShovelPatch.SetLogSource(mls);
			CustomEnemyDeaths.SetLogSource(mls);
			harmony.PatchAll();
		}

		private void setupConfig()
		{
			ConfigEntry<bool> val = ((BaseUnityPlugin)this).Config.Bind<bool>("Custom Death Animations", "CustomDeathAnimations", true, "Setting for attempting to sync death animations for enemies that can't normally die. If off the enemies will just despawn instead.");
			ConfigVariables.syncDeathAnimations = val.Value;
		}
	}
}
namespace OPJosMod.OneHitShovel.Utils
{
	public class ReflectionUtils
	{
		public static void InvokeMethod(object obj, string methodName, object[] parameters)
		{
			Type type = obj.GetType();
			MethodInfo method = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			method.Invoke(obj, parameters);
		}

		public static void InvokeMethod(object obj, Type forceType, string methodName, object[] parameters)
		{
			MethodInfo method = forceType.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			method.Invoke(obj, parameters);
		}

		public static void SetPropertyValue(object obj, string propertyName, object value)
		{
			Type type = obj.GetType();
			PropertyInfo property = type.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			property.SetValue(obj, value);
		}

		public static T InvokeMethod<T>(object obj, string methodName, object[] parameters)
		{
			Type type = obj.GetType();
			MethodInfo method = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			return (T)method.Invoke(obj, parameters);
		}

		public static T GetFieldValue<T>(object obj, string fieldName)
		{
			Type type = obj.GetType();
			FieldInfo field = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			return (T)field.GetValue(obj);
		}

		public static void SetFieldValue(object obj, string fieldName, object value)
		{
			Type type = obj.GetType();
			FieldInfo field = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			field.SetValue(obj, value);
		}
	}
}
namespace OPJosMod.OneHitShovel.Patches
{
	[HarmonyPatch(typeof(Shovel))]
	internal class ShovelPatch
	{
		private static ManualLogSource mls;

		public static void SetLogSource(ManualLogSource logSource)
		{
			mls = logSource;
		}

		[HarmonyPatch("HitShovel")]
		[HarmonyPrefix]
		private static void hitShovelPatch(Shovel __instance)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_008f: 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_01a9: Unknown result type (might be due to invalid IL or missing references)
			if (!GlobalVariables.ModActivated)
			{
				return;
			}
			try
			{
				__instance.shovelHitForce = 30;
				GameObject val = null;
				PlayerControllerB fieldValue = ReflectionUtils.GetFieldValue<PlayerControllerB>(__instance, "previousPlayerHeldBy");
				RaycastHit[] fieldValue2 = ReflectionUtils.GetFieldValue<RaycastHit[]>(__instance, "objectsHitByShovel");
				List<RaycastHit> fieldValue3 = ReflectionUtils.GetFieldValue<List<RaycastHit>>(__instance, "objectsHitByShovelList");
				int fieldValue4 = ReflectionUtils.GetFieldValue<int>(__instance, "shovelMask");
				fieldValue2 = Physics.SphereCastAll(((Component)fieldValue.gameplayCamera).transform.position + ((Component)fieldValue.gameplayCamera).transform.right * -0.35f, 0.8f, ((Component)fieldValue.gameplayCamera).transform.forward, 1.5f, fieldValue4, (QueryTriggerInteraction)2);
				fieldValue3 = fieldValue2.OrderBy((RaycastHit x) => ((RaycastHit)(ref x)).distance).ToList();
				IHittable val3 = default(IHittable);
				for (int i = 0; i < fieldValue3.Count; i++)
				{
					RaycastHit val2 = fieldValue3[i];
					if (((Component)((RaycastHit)(ref val2)).transform).TryGetComponent<IHittable>(ref val3) && !((Object)((Component)((RaycastHit)(ref val2)).transform).gameObject).name.Contains("Player"))
					{
						mls.LogMessage((object)("Hit object: " + ((Object)((Component)((RaycastHit)(ref val2)).transform).gameObject).name));
						val = ((Component)((RaycastHit)(ref val2)).transform).gameObject;
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					CustomEnemyDeaths.KillGameObjectEnemy(val);
					CustomEnemyDeaths.updateLocationOnServer(val);
				}
				Vector3? val4 = checkIfHitMech();
				if (val4.HasValue)
				{
					((MonoBehaviour)StartOfRound.Instance.localPlayerController).StartCoroutine(CustomEnemyDeaths.KillMech(val4.Value, updateOnServer: true));
				}
			}
			catch (Exception ex)
			{
				mls.LogError((object)ex);
			}
		}

		private static Vector3? checkIfHitMech()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
				RadMechAI[] array = Object.FindObjectsOfType<RadMechAI>();
				if (array.Length == 0)
				{
					return null;
				}
				RadMechAI val = null;
				float num = float.PositiveInfinity;
				RadMechAI[] array2 = array;
				foreach (RadMechAI val2 in array2)
				{
					Vector3 val3 = ((Component)val2).transform.position - ((Component)localPlayerController).transform.position;
					if (Vector3.Dot(((Component)localPlayerController).transform.forward, ((Vector3)(ref val3)).normalized) > 0.5f)
					{
						float magnitude = ((Vector3)(ref val3)).magnitude;
						if (magnitude <= 3f && magnitude < num)
						{
							num = magnitude;
							val = val2;
						}
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				return ((Component)val).transform.position;
			}
			catch
			{
				return null;
			}
		}
	}
}
namespace OPJosMod.OneHitShovel.CustomRpc
{
	public static class CompleteRecievedTasks
	{
		private static ManualLogSource mls;

		public static void SetLogSource(ManualLogSource logSource)
		{
			mls = logSource;
		}

		public static void ModActivated(string modName)
		{
			if (mls.SourceName == modName)
			{
				mls.LogMessage((object)"Mod Activated");
				GlobalVariables.ModActivated = true;
			}
		}

		public static void EnemyDied(string position)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Vector3 location = GeneralUtil.StringToVector3(position);
			EnemyAI val = CustomEnemyDeaths.findClosestEnemyAI(location);
			if ((Object)(object)val != (Object)null)
			{
				CustomEnemyDeaths.KillAnyEnemy(val);
			}
			else
			{
				mls.LogMessage((object)"couldnt find enemy to kill");
			}
		}
	}
	public enum MessageCodes
	{
		Request,
		Response
	}
	public static class MessageCodeUtil
	{
		public static string GetCode(MessageCodes code)
		{
			return code switch
			{
				MessageCodes.Request => ":rpcRequest:", 
				MessageCodes.Response => ":rpcResponse:", 
				_ => ":Error:", 
			};
		}

		public static bool stringContainsMessageCode(string givenString)
		{
			return givenString.Contains(GetCode(MessageCodes.Request)) || givenString.Contains(GetCode(MessageCodes.Response));
		}

		public static string returnMessageWithoutCode(string message)
		{
			if (stringContainsMessageCode(message))
			{
				int length = GetCode(MessageCodes.Request).Length;
				return message.Substring(length);
			}
			return message;
		}
	}
	public enum MessageTasks
	{
		ModActivated,
		EnemyDied,
		ErrorNoTask
	}
	public static class MessageTaskUtil
	{
		public static string GetCode(MessageTasks code)
		{
			return code switch
			{
				MessageTasks.ModActivated => ":ModActivated:", 
				MessageTasks.EnemyDied => ":EnemyDied:", 
				MessageTasks.ErrorNoTask => ":Error:", 
				_ => ":Error:", 
			};
		}

		public static string getMessageWithoutTask(string message)
		{
			foreach (MessageTasks value in Enum.GetValues(typeof(MessageTasks)))
			{
				string code2 = GetCode(value);
				message = message.Replace(code2, "");
			}
			return message.Trim();
		}

		public static MessageTasks getMessageTask(string givenString)
		{
			if (givenString.Contains(GetCode(MessageTasks.ModActivated)))
			{
				return MessageTasks.ModActivated;
			}
			if (givenString.Contains(GetCode(MessageTasks.EnemyDied)))
			{
				return MessageTasks.EnemyDied;
			}
			return MessageTasks.ErrorNoTask;
		}
	}
	public class RpcMessage
	{
		public string Message { get; set; }

		public int FromUser { get; set; }

		public MessageCodes MessageCode { get; set; }

		public RpcMessage(string message, int user, MessageCodes code)
		{
			Message = message;
			FromUser = user;
			MessageCode = code;
		}

		public string getMessageWithCode()
		{
			return MessageCodeUtil.GetCode(MessageCode) + Message;
		}
	}
	public static class RpcMessageHandler
	{
		private static ManualLogSource mls;

		private static float lastSentTime = Time.time;

		private static float messageWaitTime = 1f;

		public static void SetLogSource(ManualLogSource logSource)
		{
			mls = logSource;
		}

		public static void SendRpcMessage(RpcMessage message)
		{
			if (!(Time.time - lastSentTime > messageWaitTime))
			{
				return;
			}
			lastSentTime = Time.time;
			HUDManager instance = HUDManager.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				MethodInfo method = typeof(HUDManager).GetMethod("AddPlayerChatMessageServerRpc", BindingFlags.Instance | BindingFlags.NonPublic);
				if (method != null)
				{
					object[] parameters = new object[2]
					{
						message.getMessageWithCode(),
						message.FromUser
					};
					method.Invoke(instance, parameters);
				}
				else
				{
					mls.LogError((object)"AddPlayerChatMessageServerRpc method not found in HUDManager class.");
				}
			}
			else
			{
				mls.LogError((object)"HUDManager.Instance is null.");
			}
		}

		public static void ReceiveRpcMessage(string message, int user)
		{
			if (user != (int)StartOfRound.Instance.localPlayerController.playerClientId)
			{
				string text = MessageCodeUtil.returnMessageWithoutCode(message);
				if (message.Contains(MessageCodeUtil.GetCode(MessageCodes.Request)))
				{
					MessageTasks messageTask = MessageTaskUtil.getMessageTask(text);
					string messageWithoutTask = MessageTaskUtil.getMessageWithoutTask(text);
					handleTask(messageTask, messageWithoutTask);
				}
				else if (message.Contains(MessageCodeUtil.GetCode(MessageCodes.Response)))
				{
					mls.LogMessage((object)"got the response that the other clients recieved this message");
				}
			}
		}

		public static void SendRpcResponse(string message)
		{
			RpcMessage message2 = new RpcMessage(message, (int)StartOfRound.Instance.localPlayerController.playerClientId, MessageCodes.Response);
			SendRpcMessage(message2);
		}

		private static void handleTask(MessageTasks task, string message)
		{
			switch (task)
			{
			case MessageTasks.ModActivated:
				CompleteRecievedTasks.ModActivated(message);
				break;
			case MessageTasks.EnemyDied:
				CompleteRecievedTasks.EnemyDied(message);
				break;
			case MessageTasks.ErrorNoTask:
				mls.LogError((object)"got an error task");
				break;
			}
		}
	}
	public static class PatchesForRPC
	{
		public static ManualLogSource mls;

		public static void SetLogSource(ManualLogSource logSource)
		{
			mls = logSource;
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	internal static class HUDManagerPatchForRPC
	{
		private static float lastRecievedAt = Time.time;

		private static string lastRecievedMessage = "";

		private static float messageWaitTime = 0.5f;

		[HarmonyPatch("AddPlayerChatMessageClientRpc")]
		[HarmonyPrefix]
		private static void addPlayerChatMessageClientRpcPatch(ref string chatMessage, ref int playerId)
		{
			if (MessageCodeUtil.stringContainsMessageCode(chatMessage) && (Time.time - lastRecievedAt > messageWaitTime || chatMessage != lastRecievedMessage))
			{
				lastRecievedAt = Time.time;
				lastRecievedMessage = chatMessage;
				RpcMessageHandler.ReceiveRpcMessage(chatMessage, playerId);
			}
		}

		[HarmonyPatch("AddChatMessage")]
		[HarmonyPrefix]
		private static bool addChatMessagePatch(ref string chatMessage)
		{
			if (MessageCodeUtil.stringContainsMessageCode(chatMessage))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal static class StartOfRoundPatchForRPC
	{
		[HarmonyPatch("OnClientConnect")]
		[HarmonyPostfix]
		private static void patchOnClientConnect(StartOfRound __instance)
		{
			((MonoBehaviour)__instance).StartCoroutine(activateModForOthers(__instance));
		}

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void patchStart(StartOfRound __instance)
		{
			if (((NetworkBehaviour)__instance).IsHost)
			{
				GlobalVariables.ModActivated = true;
			}
		}

		[HarmonyPatch("OnLocalDisconnect")]
		[HarmonyPostfix]
		private static void patchOnLocalDisconnect(StartOfRound __instance)
		{
			GlobalVariables.ModActivated = false;
		}

		private static IEnumerator activateModForOthers(StartOfRound __instance)
		{
			yield return (object)new WaitForSeconds(3f);
			if (((NetworkBehaviour)__instance).IsHost)
			{
				GlobalVariables.ModActivated = true;
				string message = MessageTaskUtil.GetCode(MessageTasks.ModActivated) + PatchesForRPC.mls.SourceName;
				RpcMessage rpcMessage = new RpcMessage(message, (int)__instance.localPlayerController.playerClientId, MessageCodes.Request);
				RpcMessageHandler.SendRpcMessage(rpcMessage);
			}
		}
	}
}