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.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FishNet;
using FishNet.Managing.Scened;
using FishNet.Object;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MyceliumNetworking;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("JuggernautMod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+050bd9079816db1277721bebf5e089774c1ffaee")]
[assembly: AssemblyProduct("JuggernautMod")]
[assembly: AssemblyTitle("JuggernautMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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 JuggernautMod
{
	public class JuggernautHud : MonoBehaviour
	{
		private const float RefreshInterval = 0.25f;

		private GameObject _panel;

		private TextMeshProUGUI _text;

		private float _nextRefreshTime;

		private void Awake()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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)
			//IL_00bd: 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_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Expected O, but got Unknown
			Canvas obj = ((Component)this).gameObject.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 1000;
			CanvasScaler obj2 = ((Component)this).gameObject.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = new Vector2(1920f, 1080f);
			_panel = new GameObject("JuggernautPanel");
			_panel.transform.SetParent(((Component)this).transform, false);
			RectTransform obj3 = _panel.AddComponent<RectTransform>();
			obj3.anchorMin = new Vector2(1f, 1f);
			obj3.anchorMax = new Vector2(1f, 1f);
			obj3.pivot = new Vector2(1f, 1f);
			obj3.anchoredPosition = new Vector2(-18f, -440f);
			((Graphic)_panel.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.45f);
			VerticalLayoutGroup obj4 = _panel.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj4).padding = new RectOffset(12, 12, 8, 8);
			((LayoutGroup)obj4).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)obj4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj4).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj4).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj4).childForceExpandHeight = false;
			ContentSizeFitter obj5 = _panel.AddComponent<ContentSizeFitter>();
			obj5.horizontalFit = (FitMode)2;
			obj5.verticalFit = (FitMode)2;
			GameObject val = new GameObject("JuggernautText");
			val.transform.SetParent(_panel.transform, false);
			val.AddComponent<RectTransform>();
			_text = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)_text).fontSize = 22f;
			((TMP_Text)_text).richText = true;
			((TMP_Text)_text).enableWordWrapping = false;
			((TMP_Text)_text).alignment = (TextAlignmentOptions)257;
			((Graphic)_text).raycastTarget = false;
			_panel.SetActive(false);
		}

		private void Update()
		{
			if (!(Time.unscaledTime < _nextRefreshTime))
			{
				_nextRefreshTime = Time.unscaledTime + 0.25f;
				bool flag = JuggernautPlugin.ShowHud.Value && JuggernautManager.ModeActiveLocally() && (Object)(object)PauseManager.Instance != (Object)null && !PauseManager.Instance.inMainMenu && !PauseManager.Instance.inVictoryMenu && ClientInstance.playerInstances.Count > 0;
				if (_panel.activeSelf != flag)
				{
					_panel.SetActive(flag);
				}
				if (flag)
				{
					((TMP_Text)_text).text = BuildText();
				}
			}
		}

		private static string BuildText()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("<b><color=#FF6A00>JUGGURNAUGHT</color></b>  <color=#AAAAAA>first to ").Append(JuggernautManager.EffectivePointsToWin).Append(" • ")
				.Append(JuggernautManager.EffectiveTakesToWin)
				.Append((JuggernautManager.EffectiveTakesToWin == 1) ? " take wins" : " takes win")
				.Append("</color>");
			int jugId = JuggernautManager.JugPlayerId;
			List<KeyValuePair<int, int>> list = new List<KeyValuePair<int, int>>();
			foreach (KeyValuePair<int, ClientInstance> playerInstance in ClientInstance.playerInstances)
			{
				JuggernautManager.Points.TryGetValue(playerInstance.Key, out var value);
				list.Add(new KeyValuePair<int, int>(playerInstance.Key, value));
			}
			foreach (KeyValuePair<int, int> item in from r in list
				orderby r.Key == jugId descending, r.Value descending
				select r)
			{
				stringBuilder.Append('\n');
				string playerNameTag = JuggernautManager.GetPlayerNameTag(item.Key);
				if (item.Key == jugId)
				{
					stringBuilder.Append("<color=#FF6A00><b>").Append(playerNameTag).Append("</b>  ")
						.Append(item.Value)
						.Append("  <b>JUG</b></color>");
				}
				else
				{
					stringBuilder.Append("<color=#DDDDDD>").Append(playerNameTag).Append("  ")
						.Append(item.Value)
						.Append("</color>");
				}
				int takeWins = GetTakeWins(item.Key);
				if (takeWins > 0)
				{
					stringBuilder.Append("  <color=#FFD24A>").Append((takeWins == 1) ? "1 take" : (takeWins + " takes")).Append("</color>");
				}
			}
			if (jugId < 0)
			{
				stringBuilder.Append("\n<color=#AAAAAA>First blood claims the crown!</color>");
			}
			try
			{
				return ClientInstance.ReplaceAllPlayerNameTags(stringBuilder.ToString());
			}
			catch
			{
				return stringBuilder.ToString();
			}
		}

		private static int GetTakeWins(int playerId)
		{
			try
			{
				if ((Object)(object)ScoreManager.Instance == (Object)null)
				{
					return 0;
				}
				return ScoreManager.Instance.GetRoundScore(ScoreManager.Instance.GetTeamId(playerId));
			}
			catch
			{
				return 0;
			}
		}
	}
	public static class JuggernautManager
	{
		private const string ChatTag = "<b><color=#FF6A00>[JUGGURNAUGHT]</color></b>";

		private const string SyncMarker = "[[JUGSYNC]]|";

		public static int JugPlayerId = -1;

		public static readonly Dictionary<int, int> Points = new Dictionary<int, int>();

		public static int EffectivePointsToWin = 100;

		public static int EffectiveTakesToWin = 2;

		public static int EffectiveSpeedBoostPercent = 0;

		public static float LastSyncTime = -1000f;

		private static float _pointAccumulator = 0f;

		private static float _nextBroadcastTime = 0f;

		private static float _lastAnnounceTime = -1000f;

		private static bool _winSequenceInProgress = false;

		private static readonly HashSet<int> _grantedHealthInstances = new HashSet<int>();

		private static MethodInfo _miRoundWon;

		private static MethodInfo _miUpdateMatchPointsHud;

		private static bool _reflectionCached = false;

		public static void ResetState()
		{
			JugPlayerId = -1;
			Points.Clear();
			_pointAccumulator = 0f;
			_nextBroadcastTime = 0f;
			_winSequenceInProgress = false;
			_grantedHealthInstances.Clear();
		}

		private static void CacheReflection()
		{
			if (_reflectionCached)
			{
				return;
			}
			_reflectionCached = true;
			_miRoundWon = typeof(GameManager).GetMethod("RoundWon", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (_miRoundWon == null)
			{
				ManualLogSource log = JuggernautPlugin.Log;
				if (log != null)
				{
					log.LogError((object)"[Juggernaut] GameManager.RoundWon was not found");
				}
			}
			_miUpdateMatchPointsHud = typeof(GameManager).GetMethod("UpdateMatchPointsHUD", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (_miUpdateMatchPointsHud == null)
			{
				ManualLogSource log2 = JuggernautPlugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)"[Juggernaut] GameManager.UpdateMatchPointsHUD was not found");
				}
			}
		}

		public static bool ModeActiveLocally()
		{
			if ((Object)(object)GameManager.Instance == (Object)null)
			{
				return false;
			}
			if ((Object)(object)InstanceFinder.NetworkManager != (Object)null && InstanceFinder.NetworkManager.IsServer)
			{
				return JuggernautPlugin.Enabled.Value;
			}
			return Time.unscaledTime - LastSyncTime < 4f;
		}

		public static void ServerUpdate()
		{
			EffectivePointsToWin = JuggernautPlugin.PointsToWin.Value;
			EffectiveTakesToWin = JuggernautPlugin.TakesToWin.Value;
			EffectiveSpeedBoostPercent = JuggernautPlugin.SpeedBoostPercent.Value;
			if (JugPlayerId >= 0 && !ClientInstance.playerInstances.ContainsKey(JugPlayerId))
			{
				JugPlayerId = -1;
				_pointAccumulator = 0f;
				BroadcastChat("<b><color=#FF6A00>[JUGGURNAUGHT]</color></b> The Juggernaut left the game! <color=#FF6A00>First blood claims the crown!</color>");
				BroadcastState();
			}
			if (JugPlayerId >= 0 && !_winSequenceInProgress)
			{
				PlayerHealth val = FindPlayerHealthById(JugPlayerId);
				if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeInHierarchy && !val.sync___get_value_isKilled() && val.sync___get_value_health() > 0f)
				{
					int instanceID = ((Object)val).GetInstanceID();
					if (!_grantedHealthInstances.Contains(instanceID))
					{
						_grantedHealthInstances.Add(instanceID);
						GrantBonusHealth(val);
					}
					_pointAccumulator += Time.deltaTime;
					bool flag = false;
					while (_pointAccumulator >= 1f)
					{
						_pointAccumulator -= 1f;
						AddPoints(JugPlayerId, JuggernautPlugin.PointsPerSecond.Value);
						flag = true;
					}
					if (flag && Points[JugPlayerId] >= EffectivePointsToWin)
					{
						Points[JugPlayerId] = EffectivePointsToWin;
						StartWinSequence(JugPlayerId);
						BroadcastState();
						return;
					}
				}
				else
				{
					_pointAccumulator = 0f;
				}
			}
			ServerBroadcastTick();
		}

		public static void ServerBroadcastTick()
		{
			if (Time.unscaledTime >= _nextBroadcastTime)
			{
				_nextBroadcastTime = Time.unscaledTime + 1f;
				BroadcastState();
			}
		}

		public static void OnServerKill(int deadPlayerId, int killerId)
		{
			if (_winSequenceInProgress || JuggernautPlugin.MatchOver)
			{
				return;
			}
			bool flag = killerId >= 0 && killerId != deadPlayerId;
			if (JugPlayerId < 0)
			{
				if (flag)
				{
					BecomeJuggernaut(killerId, string.Format("{0} <b>{1}</b> drew <color=red>first blood</color> and <color=#FF6A00>IS THE JUGGERNAUT!</color> <color=#AAAAAA>(+{2} HP)</color>", "<b><color=#FF6A00>[JUGGURNAUGHT]</color></b>", GetPlayerNameTag(killerId), JuggernautPlugin.BonusHealth.Value));
				}
			}
			else if (deadPlayerId == JugPlayerId)
			{
				if (flag)
				{
					BecomeJuggernaut(killerId, string.Format("{0} <b>{1}</b> <color=red>slayed</color> the Juggernaut <b>{2}</b> and <color=#FF6A00>CLAIMED THE CROWN!</color> <color=#AAAAAA>(+{3} HP)</color>", "<b><color=#FF6A00>[JUGGURNAUGHT]</color></b>", GetPlayerNameTag(killerId), GetPlayerNameTag(deadPlayerId), JuggernautPlugin.BonusHealth.Value));
				}
				else
				{
					BroadcastChat("<b><color=#FF6A00>[JUGGURNAUGHT]</color></b> The Juggernaut <b>" + GetPlayerNameTag(deadPlayerId) + "</b> <color=#888888>died... but keeps the crown.</color>");
				}
			}
			else
			{
				if (!flag || killerId != JugPlayerId || JuggernautPlugin.HealthPerKill.Value <= 0)
				{
					return;
				}
				PlayerHealth val = FindPlayerHealthById(killerId);
				if (!((Object)(object)val != (Object)null) || !((Component)val).gameObject.activeInHierarchy || val.sync___get_value_isKilled() || !(val.sync___get_value_health() > 0f))
				{
					return;
				}
				try
				{
					val.RpcLogic___RemoveHealth_431000436(0f - (float)JuggernautPlugin.HealthPerKill.Value / 25f);
					BroadcastChat(string.Format("{0} <b>{1}</b> <color=#66DD66>+{2} HP</color> <color=#AAAAAA>for the kill</color>", "<b><color=#FF6A00>[JUGGURNAUGHT]</color></b>", GetPlayerNameTag(killerId), JuggernautPlugin.HealthPerKill.Value));
				}
				catch (Exception ex)
				{
					ManualLogSource log = JuggernautPlugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[Juggernaut] health-per-kill grant failed: " + ex.GetType().Name));
					}
				}
			}
		}

		private static void BecomeJuggernaut(int playerId, string announcement)
		{
			JugPlayerId = playerId;
			_pointAccumulator = 0f;
			_grantedHealthInstances.Clear();
			PlayerHealth val = FindPlayerHealthById(playerId);
			if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeInHierarchy && !val.sync___get_value_isKilled() && val.sync___get_value_health() > 0f)
			{
				_grantedHealthInstances.Add(((Object)val).GetInstanceID());
				GrantBonusHealth(val);
			}
			BroadcastChat(announcement);
			BroadcastState();
		}

		private static void GrantBonusHealth(PlayerHealth health)
		{
			try
			{
				float num = (float)JuggernautPlugin.BonusHealth.Value / 25f;
				health.RpcLogic___RemoveHealth_431000436(0f - num);
				ManualLogSource log = JuggernautPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"[Juggernaut] granted +{JuggernautPlugin.BonusHealth.Value} HP to player {JugPlayerId}");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = JuggernautPlugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[Juggernaut] bonus health grant failed: " + ex.GetType().Name));
				}
			}
		}

		private static void AddPoints(int playerId, int amount)
		{
			Points.TryGetValue(playerId, out var value);
			Points[playerId] = value + amount;
		}

		private static void StartWinSequence(int winnerPlayerId)
		{
			if (!_winSequenceInProgress)
			{
				_winSequenceInProgress = true;
				JuggernautPlugin.MatchOver = true;
				object obj = ((object)GameManager.Instance) ?? ((object)JuggernautPlugin.Instance);
				if (obj != null)
				{
					((MonoBehaviour)obj).StartCoroutine(WinSequenceCoroutine(winnerPlayerId));
				}
			}
		}

		private static IEnumerator WinSequenceCoroutine(int winnerPlayerId)
		{
			CacheReflection();
			yield return (object)new WaitForSeconds(1.5f);
			int num = GetPlayerTeam(winnerPlayerId);
			bool flag = false;
			int num2 = 0;
			try
			{
				if ((Object)(object)ScoreManager.Instance != (Object)null)
				{
					ScoreManager.Instance.RoundScoreRequiredToWin = EffectiveTakesToWin;
					ScoreManager.Instance.AddRoundScore(num, 1);
					num2 = ScoreManager.Instance.GetRoundScore(num);
					int num3 = default(int);
					flag = ScoreManager.Instance.CheckForRoundWin(ref num3);
					if (flag)
					{
						num = num3;
					}
					_miUpdateMatchPointsHud?.Invoke(GameManager.Instance, new object[2]
					{
						flag ? num : (-1),
						ScoreManager.Instance.GetRoundScoreDictionary()
					});
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = JuggernautPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[Juggernaut] take scoring error: " + ex.GetType().Name));
				}
			}
			if (flag)
			{
				bool endRoundCalled = false;
				try
				{
					BroadcastChat("<b><color=#FF6A00>[JUGGURNAUGHT]</color></b> <b>" + GetPlayerNameTag(winnerPlayerId) + "</b> takes the final take and <color=yellow>WINS THE ROUND!</color>");
					if (_miRoundWon != null)
					{
						_miRoundWon.Invoke(GameManager.Instance, new object[1] { num });
					}
					if ((Object)(object)RoundManager.Instance != (Object)null)
					{
						RoundManager.Instance.CmdEndRound(num);
						endRoundCalled = true;
					}
				}
				catch (Exception ex2)
				{
					ManualLogSource log2 = JuggernautPlugin.Log;
					if (log2 != null)
					{
						log2.LogWarning((object)("[Juggernaut] round win sequence error: " + ex2.GetType().Name));
					}
				}
				yield return (object)new WaitForSeconds(4f);
				if (endRoundCalled)
				{
					try
					{
						if ((Object)(object)SceneMotor.Instance != (Object)null)
						{
							SceneMotor.Instance.ChangeNetworkScene();
						}
					}
					catch
					{
					}
				}
				JuggernautPlugin.MatchOver = false;
				ResetState();
				yield break;
			}
			BroadcastChat(string.Format("{0} <b>{1}</b> reached <b>{2}</b> points and <color=yellow>WINS THE TAKE!</color> <color=#AAAAAA>({3}/{4} takes)</color>", "<b><color=#FF6A00>[JUGGURNAUGHT]</color></b>", GetPlayerNameTag(winnerPlayerId), EffectivePointsToWin, num2, EffectiveTakesToWin));
			yield return (object)new WaitForSeconds(2f);
			JuggernautPatches.ResetState();
			ResetState();
			JuggernautPlugin.MatchOver = false;
			try
			{
				GameManager instance = GameManager.Instance;
				if (instance != null)
				{
					instance.ProgressToNextTake();
				}
			}
			catch (Exception ex3)
			{
				ManualLogSource log3 = JuggernautPlugin.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)("[Juggernaut] take transition error: " + ex3.GetType().Name));
				}
			}
			BroadcastState();
			yield return (object)new WaitForSeconds(2.5f);
			if (JuggernautPlugin.Enabled.Value && !JuggernautPlugin.MatchOver && JugPlayerId < 0)
			{
				BroadcastChat("<b><color=#FF6A00>[JUGGURNAUGHT]</color></b> <color=#FF6A00>New take — first blood claims the crown!</color>");
			}
		}

		public static void AnnounceRoundStartDelayed()
		{
			JuggernautPlugin instance = JuggernautPlugin.Instance;
			if (instance != null)
			{
				((MonoBehaviour)instance).StartCoroutine(AnnounceRoundStartCoroutine());
			}
		}

		private static IEnumerator AnnounceRoundStartCoroutine()
		{
			yield return (object)new WaitForSeconds(3f);
			if (JuggernautPlugin.Enabled.Value && !JuggernautPlugin.MatchOver && !((Object)(object)GameManager.Instance == (Object)null) && JugPlayerId < 0 && !(Time.unscaledTime - _lastAnnounceTime < 15f))
			{
				_lastAnnounceTime = Time.unscaledTime;
				BroadcastChat(string.Format("{0} <color=#FF6A00>First blood claims the crown!</color> Hold it to earn points — first to <b>{1}</b> wins the round.", "<b><color=#FF6A00>[JUGGURNAUGHT]</color></b>", JuggernautPlugin.PointsToWin.Value));
			}
		}

		internal static void BroadcastState()
		{
			if (!((Object)(object)InstanceFinder.NetworkManager == (Object)null) && InstanceFinder.NetworkManager.IsServer && !JuggernautPlugin.TryBroadcastStateOverMycelium())
			{
				JuggernautPatches.SendChatLineToAll(string.Format("{0}{1}|{2}|{3}|{4}|{5}", "[[JUGSYNC]]|", JugPlayerId, EffectivePointsToWin, EffectiveTakesToWin, EffectiveSpeedBoostPercent, SerializePoints()));
			}
		}

		internal static bool TryHandleSyncLine(string line)
		{
			if (line == null || !line.StartsWith("[[JUGSYNC]]|", StringComparison.Ordinal))
			{
				return false;
			}
			try
			{
				if ((Object)(object)InstanceFinder.NetworkManager == (Object)null || !InstanceFinder.NetworkManager.IsServer)
				{
					string[] array = line.Substring("[[JUGSYNC]]|".Length).Split(new char[1] { '|' });
					if (array.Length >= 5 && int.TryParse(array[0], out var result) && int.TryParse(array[1], out var result2) && int.TryParse(array[2], out var result3) && int.TryParse(array[3], out var result4))
					{
						ApplySyncedState(result, result2, result3, result4, array[4]);
					}
				}
			}
			catch
			{
			}
			return true;
		}

		public static string SerializePoints()
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (KeyValuePair<int, int> point in Points)
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append(';');
				}
				stringBuilder.Append(point.Key).Append(':').Append(point.Value);
			}
			return stringBuilder.ToString();
		}

		public static void ApplySyncedState(int jugPlayerId, int pointsToWin, int takesToWin, int speedBoostPercent, string pointsData)
		{
			JugPlayerId = jugPlayerId;
			EffectivePointsToWin = pointsToWin;
			EffectiveTakesToWin = takesToWin;
			EffectiveSpeedBoostPercent = speedBoostPercent;
			LastSyncTime = Time.unscaledTime;
			Points.Clear();
			if (string.IsNullOrEmpty(pointsData))
			{
				return;
			}
			string[] array = pointsData.Split(new char[1] { ';' });
			foreach (string text in array)
			{
				int num = text.IndexOf(':');
				if (num > 0 && int.TryParse(text.Substring(0, num), out var result) && int.TryParse(text.Substring(num + 1), out var result2))
				{
					Points[result] = result2;
				}
			}
		}

		internal static void BroadcastChat(string text)
		{
			JuggernautPatches.SendChatLineToAll(text);
		}

		internal static string GetPlayerNameTag(int playerId)
		{
			try
			{
				if (ClientInstance.playerInstances.TryGetValue(playerId, out var value) && (Object)(object)value != (Object)null)
				{
					return value.PlayerNameTag;
				}
			}
			catch
			{
			}
			return $"Player {playerId}";
		}

		internal static int GetPlayerTeam(int playerId)
		{
			if ((Object)(object)ScoreManager.Instance != (Object)null)
			{
				try
				{
					return ScoreManager.Instance.GetTeamId(playerId);
				}
				catch
				{
				}
			}
			return playerId;
		}

		internal static PlayerHealth FindPlayerHealthById(int playerId)
		{
			if (playerId < 0)
			{
				return null;
			}
			try
			{
				PlayerHealth[] array = Object.FindObjectsOfType<PlayerHealth>(true);
				foreach (PlayerHealth val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						PlayerValues obj = val.sync___get_value_playerValues();
						if ((((obj == null) ? ((int?)null) : obj.sync___get_value_playerClient()?.PlayerId) ?? (-1)) == playerId)
						{
							return val;
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}
	}
	public static class JuggernautOutline
	{
		private const string HeadMeshName = "SM_Aboubi_Head00";

		private static int _outlinedPlayerId = -1;

		private static readonly List<SkinnedMeshRenderer> _outlinedRenderers = new List<SkinnedMeshRenderer>();

		private static readonly FieldInfo _fiBodyMeshes = typeof(PlayerSetup).GetField("gameObjectsToDisableForMe", BindingFlags.Instance | BindingFlags.NonPublic);

		public static void ResetState()
		{
			_outlinedPlayerId = -1;
			_outlinedRenderers.Clear();
		}

		public static void EnforceOutline()
		{
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			int num = (JuggernautManager.ModeActiveLocally() ? JuggernautManager.JugPlayerId : (-1));
			if (num != _outlinedPlayerId)
			{
				ClearOutline();
				_outlinedPlayerId = num;
			}
			if (num < 0 || ((Object)(object)ClientInstance.Instance != (Object)null && ClientInstance.Instance.PlayerId == num))
			{
				return;
			}
			try
			{
				PlayerHealth val = JuggernautManager.FindPlayerHealthById(num);
				if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeInHierarchy)
				{
					return;
				}
				PlayerSetup component = ((Component)val).GetComponent<PlayerSetup>();
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				GameObject[] array = _fiBodyMeshes?.GetValue(component) as GameObject[];
				if (array == null || array.Length == 0)
				{
					array = component.meshesToChange;
				}
				if (array == null)
				{
					return;
				}
				_outlinedRenderers.Clear();
				GameObject[] array2 = array;
				foreach (GameObject val2 in array2)
				{
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					SkinnedMeshRenderer component2 = val2.GetComponent<SkinnedMeshRenderer>();
					if (!((Object)(object)component2 == (Object)null))
					{
						Material[] materials = ((Renderer)component2).materials;
						if (materials != null && materials.Length != 0 && !((Object)(object)materials[0] == (Object)null) && materials[0].HasProperty("_ASEOutlineWidth"))
						{
							float num2 = ((((Object)val2).name == "SM_Aboubi_Head00") ? 0.02f : 0.04f) * OutlineHandler.OutlineWidthMultiplier;
							materials[0].SetFloat("_ASEOutlineWidth", num2);
							materials[0].SetColor("_ASEOutlineColor", OutlineHandler.TeamColor);
							((Renderer)component2).materials = materials;
							_outlinedRenderers.Add(component2);
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = JuggernautPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[Juggernaut] outline enforcement failed: " + ex.GetType().Name));
				}
			}
		}

		private static void ClearOutline()
		{
			foreach (SkinnedMeshRenderer outlinedRenderer in _outlinedRenderers)
			{
				try
				{
					if (!((Object)(object)outlinedRenderer == (Object)null))
					{
						Material[] materials = ((Renderer)outlinedRenderer).materials;
						if (materials != null && materials.Length != 0 && !((Object)(object)materials[0] == (Object)null) && materials[0].HasProperty("_ASEOutlineWidth"))
						{
							materials[0].SetFloat("_ASEOutlineWidth", 0f);
							((Renderer)outlinedRenderer).materials = materials;
						}
					}
				}
				catch
				{
				}
			}
			_outlinedRenderers.Clear();
		}
	}
	public static class JuggernautPatches
	{
		private static Harmony _harmony;

		private static Dictionary<int, GameObject> _playerRagdolls = new Dictionary<int, GameObject>();

		private static HashSet<int> _respawnInProgress = new HashSet<int>();

		private static Dictionary<int, int> _respawnRequestSeq = new Dictionary<int, int>();

		private static HashSet<int> _playersAwaitingRespawn = new HashSet<int>();

		private static Dictionary<int, float> _nextRespawnRecoveryTime = new Dictionary<int, float>();

		private static Dictionary<int, float> _lastDeathHandledTime = new Dictionary<int, float>();

		private static float _nextRespawnWatchdogTime;

		private const float DeathDedupeSeconds = 0.35f;

		private const int MaxRespawnAttempts = 3;

		private const float RespawnValidationSeconds = 2f;

		private const float RespawnRetryDelaySeconds = 0.25f;

		private const float RespawnWatchdogIntervalSeconds = 0.5f;

		private const float RespawnRecoveryDelaySeconds = 1f;

		private static MethodInfo _miCmdRespawnLogic;

		private static MethodInfo _miMatchLogsSendToAll;

		public static void Apply()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			if (_harmony != null)
			{
				return;
			}
			_harmony = new Harmony("com.willofkabr.juggurnaught.patches");
			_miCmdRespawnLogic = typeof(PlayerManager).GetMethod("RpcLogic___CmdRespawn_2166136261", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (_miCmdRespawnLogic == null)
			{
				ManualLogSource log = JuggernautPlugin.Log;
				if (log != null)
				{
					log.LogError((object)"[Juggernaut Respawn] native PlayerManager respawn method was not found");
				}
			}
			_miMatchLogsSendToAll = typeof(MatchLogs).GetMethod("RpcSendChatLineToAllObservers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (_miMatchLogsSendToAll == null)
			{
				ManualLogSource log2 = JuggernautPlugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)"[Juggernaut] MatchLogs chat broadcast method was not found");
				}
			}
			try
			{
				PatchPrefix(typeof(GameManager), "WaitForDraw", "GameManager_WaitForDraw_Prefix");
				PatchPrefix(typeof(GameManager), "RpcLogic___PlayerDied_3316948804", "GameManager_RpcLogic_PlayerDied_Prefix");
				PatchPrefix(typeof(GameManager), "SetStartTime", "GameManager_SetStartTime_Prefix");
				PatchPrefix(typeof(RoundManager), "CmdEndRound", "RoundManager_CmdEndRound_Prefix");
				PatchPrefix(typeof(PlayerManager), "RpcLogic___SetPlayerMove_1140765316", "PlayerManager_RpcLogic_SetPlayerMove_Prefix");
				PatchPrefix(typeof(KillCam), "Update", "KillCam_Update_Prefix");
				PatchPrefix(typeof(PauseManager), "StartRoundDelay", "PauseManager_StartRoundDelay_Prefix");
				PatchPrefix(typeof(MatchLogs), "RpcLogic___RpcSendChatLineToAllObservers_3615296227", "MatchLogs_ChatLine_Prefix");
				PatchPostfix(typeof(PlayerManager), "SpawnPlayer", "PlayerManager_SpawnPlayer_Postfix", new Type[2]
				{
					typeof(int),
					typeof(int)
				});
				PatchPostfix(typeof(PlayerManager), "SpawnPlayer", "PlayerManager_SpawnPlayer_Postfix", new Type[4]
				{
					typeof(int),
					typeof(int),
					typeof(Vector3),
					typeof(Quaternion)
				});
				PatchPostfix(typeof(PlayerHealth), "RpcLogic___ExplodeForAll_576886416", "PlayerHealth_ExplodeForAll_Postfix");
				PatchPostfix(typeof(PlayerValues), "sync___set_value_playerClient", "PlayerValues_SetPlayerClient_Postfix");
			}
			catch (Exception arg)
			{
				ManualLogSource log3 = JuggernautPlugin.Log;
				if (log3 != null)
				{
					log3.LogError((object)$"[Juggernaut] patching failed: {arg}");
				}
			}
		}

		private static void PatchPrefix(Type type, string methodName, string patchName, Type[] paramTypes = null)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			MethodInfo methodInfo = ((paramTypes == null) ? type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) : type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, paramTypes, null));
			if (methodInfo == null)
			{
				ManualLogSource log = JuggernautPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[Juggernaut] patch target missing: " + type.Name + "." + methodName));
				}
			}
			else
			{
				_harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(JuggernautPatches).GetMethod(patchName, BindingFlags.Static | BindingFlags.Public)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static void PatchPostfix(Type type, string methodName, string patchName, Type[] paramTypes = null)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			MethodInfo methodInfo = ((paramTypes == null) ? type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) : type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, paramTypes, null));
			if (methodInfo == null)
			{
				ManualLogSource log = JuggernautPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[Juggernaut] patch target missing: " + type.Name + "." + methodName));
				}
			}
			else
			{
				_harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(JuggernautPatches).GetMethod(patchName, BindingFlags.Static | BindingFlags.Public)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		public static void ResetState()
		{
			_playerRagdolls.Clear();
			_respawnInProgress.Clear();
			_respawnRequestSeq.Clear();
			_playersAwaitingRespawn.Clear();
			_nextRespawnRecoveryTime.Clear();
			_lastDeathHandledTime.Clear();
			_nextRespawnWatchdogTime = 0f;
		}

		internal static void SendChatLineToAll(string text)
		{
			if ((Object)(object)MatchLogs.Instance == (Object)null || (Object)(object)InstanceFinder.NetworkManager == (Object)null || !InstanceFinder.NetworkManager.IsServer)
			{
				return;
			}
			try
			{
				_miMatchLogsSendToAll?.Invoke(MatchLogs.Instance, new object[1] { text });
			}
			catch
			{
			}
		}

		public static bool MatchLogs_ChatLine_Prefix(string line)
		{
			return !JuggernautManager.TryHandleSyncLine(line);
		}

		public static bool GameManager_WaitForDraw_Prefix(ref IEnumerator __result)
		{
			if (!JuggernautPlugin.Enabled.Value)
			{
				return true;
			}
			if (!JuggernautPlugin.MatchOver)
			{
				__result = EmptyCoroutine();
				return false;
			}
			return true;
		}

		private static IEnumerator EmptyCoroutine()
		{
			yield break;
		}

		public static bool RoundManager_CmdEndRound_Prefix(int winningTeamId)
		{
			if (!JuggernautPlugin.Enabled.Value)
			{
				return true;
			}
			return JuggernautPlugin.MatchOver;
		}

		public static bool KillCam_Update_Prefix()
		{
			return !JuggernautPlugin.Enabled.Value;
		}

		public static void GameManager_SetStartTime_Prefix(ref float serverTimeTillStart)
		{
			if (JuggernautPlugin.Enabled.Value && !JuggernautPlugin.MatchOver)
			{
				serverTimeTillStart = 0f;
			}
		}

		public static bool GameManager_RpcLogic_PlayerDied_Prefix(int playerId)
		{
			if (!JuggernautPlugin.Enabled.Value)
			{
				return true;
			}
			if (JuggernautPlugin.MatchOver)
			{
				return false;
			}
			try
			{
				if (GameManager.Instance?.alivePlayers != null && !GameManager.Instance.alivePlayers.Contains(playerId))
				{
					GameManager.Instance.alivePlayers.Add(playerId);
				}
				if ((Object)(object)InstanceFinder.NetworkManager == (Object)null || !InstanceFinder.NetworkManager.IsServer)
				{
					return true;
				}
				float unscaledTime = Time.unscaledTime;
				float value;
				bool num = _lastDeathHandledTime.TryGetValue(playerId, out value) && unscaledTime - value <= 0.35f;
				_lastDeathHandledTime[playerId] = unscaledTime;
				if (!num)
				{
					int killerId = FindKillerId(playerId);
					JuggernautManager.OnServerKill(playerId, killerId);
				}
				ScheduleRespawn(playerId);
			}
			catch
			{
				try
				{
					ScheduleRespawn(playerId);
				}
				catch
				{
				}
			}
			return false;
		}

		public static void PlayerManager_SpawnPlayer_Postfix(PlayerManager __instance)
		{
			if (!JuggernautPlugin.Enabled.Value || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			ClientInstance component = ((Component)__instance).GetComponent<ClientInstance>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			int playerId = component.PlayerId;
			if (playerId < 0)
			{
				return;
			}
			if ((Object)(object)InstanceFinder.NetworkManager != (Object)null && InstanceFinder.NetworkManager.IsServer && GameManager.Instance?.alivePlayers != null && !GameManager.Instance.alivePlayers.Contains(playerId))
			{
				GameManager.Instance.alivePlayers.Add(playerId);
			}
			if (((NetworkBehaviour)__instance).IsOwner)
			{
				if ((Object)(object)PauseManager.Instance != (Object)null)
				{
					PauseManager.Instance.startRound = false;
				}
				GameManager instance = GameManager.Instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(KeepPlayerMovable(__instance, 4f));
				}
			}
		}

		public static bool PlayerManager_RpcLogic_SetPlayerMove_Prefix(PlayerManager __instance, bool state)
		{
			if (!JuggernautPlugin.Enabled.Value || JuggernautPlugin.MatchOver)
			{
				return true;
			}
			if (state)
			{
				return true;
			}
			try
			{
				if ((Object)(object)__instance.player != (Object)null)
				{
					__instance.player.sync___set_value_canMove(true, true);
					__instance.player.startOfRound = false;
				}
				if ((Object)(object)PauseManager.Instance != (Object)null)
				{
					PauseManager.Instance.startRound = false;
					PauseManager.Instance.pause = false;
					PauseManager.Instance.otherPauseBools = false;
				}
			}
			catch
			{
			}
			return false;
		}

		public static bool PauseManager_StartRoundDelay_Prefix(PauseManager __instance)
		{
			if (!JuggernautPlugin.Enabled.Value)
			{
				return true;
			}
			try
			{
				__instance.InvokeRoundStarted();
				__instance.onStartRoundScreen = true;
				MonoBehaviour val = (MonoBehaviour)(((object)JuggernautPlugin.Instance) ?? ((object)GameManager.Instance));
				if ((Object)(object)val != (Object)null)
				{
					val.StartCoroutine(ClearOnStartRoundScreen(__instance));
				}
			}
			catch
			{
			}
			return false;
		}

		private static IEnumerator ClearOnStartRoundScreen(PauseManager pm)
		{
			yield return (object)new WaitForSeconds(0.8f);
			if ((Object)(object)pm != (Object)null)
			{
				pm.onStartRoundScreen = false;
			}
		}

		public static void PlayerHealth_ExplodeForAll_Postfix(PlayerHealth __instance)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (!JuggernautPlugin.Enabled.Value)
			{
				return;
			}
			try
			{
				PlayerValues obj = __instance.sync___get_value_playerValues();
				int num = ((obj == null) ? ((int?)null) : obj.sync___get_value_playerClient()?.PlayerId) ?? (-1);
				if (num < 0)
				{
					return;
				}
				RagdollDress val = null;
				float num2 = float.MaxValue;
				RagdollDress[] array = Object.FindObjectsOfType<RagdollDress>(true);
				foreach (RagdollDress val2 in array)
				{
					float num3 = Vector3.Distance(((Component)val2).transform.position, ((Component)__instance).transform.position);
					if (num3 < num2)
					{
						num2 = num3;
						val = val2;
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					_playerRagdolls[num] = ((Component)val).gameObject;
				}
			}
			catch
			{
			}
		}

		public static void PlayerValues_SetPlayerClient_Postfix(ClientInstance __0)
		{
			if (!JuggernautPlugin.Enabled.Value || (Object)(object)__0 == (Object)null)
			{
				return;
			}
			try
			{
				int playerId = __0.PlayerId;
				if (playerId >= 0)
				{
					if (_playerRagdolls.TryGetValue(playerId, out var value) && (Object)(object)value != (Object)null)
					{
						Object.Destroy((Object)(object)value);
						_playerRagdolls.Remove(playerId);
					}
					CleanupBloodAndHats();
				}
			}
			catch
			{
			}
		}

		private static void CleanupBloodAndHats()
		{
			try
			{
				ParticleSystem[] array = Object.FindObjectsOfType<ParticleSystem>(true);
				foreach (ParticleSystem val in array)
				{
					try
					{
						if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).transform.parent == (Object)null)
						{
							Object.Destroy((Object)(object)((Component)val).gameObject);
						}
					}
					catch
					{
					}
				}
				HatPosition[] array2 = Object.FindObjectsOfType<HatPosition>(true);
				foreach (HatPosition val2 in array2)
				{
					try
					{
						if ((Object)(object)((Component)val2).transform.parent == (Object)null)
						{
							Object.Destroy((Object)(object)((Component)val2).gameObject);
						}
					}
					catch
					{
					}
				}
			}
			catch
			{
			}
		}

		internal static void CleanupWorldEffects()
		{
			try
			{
				foreach (KeyValuePair<int, GameObject> playerRagdoll in _playerRagdolls)
				{
					try
					{
						if ((Object)(object)playerRagdoll.Value != (Object)null)
						{
							Object.Destroy((Object)(object)playerRagdoll.Value);
						}
					}
					catch
					{
					}
				}
				_playerRagdolls.Clear();
				RagdollDress[] array = Object.FindObjectsOfType<RagdollDress>(true);
				foreach (RagdollDress val in array)
				{
					try
					{
						Object.Destroy((Object)(object)((Component)val).gameObject);
					}
					catch
					{
					}
				}
			}
			catch
			{
			}
			CleanupBloodAndHats();
		}

		private static void ScheduleRespawn(int deadPlayerId)
		{
			if (deadPlayerId >= 0 && !JuggernautPlugin.MatchOver && !((Object)(object)GameManager.Instance == (Object)null) && !((Object)(object)InstanceFinder.NetworkManager == (Object)null) && InstanceFinder.NetworkManager.IsServer)
			{
				if (!_respawnRequestSeq.ContainsKey(deadPlayerId))
				{
					_respawnRequestSeq[deadPlayerId] = 0;
				}
				_playersAwaitingRespawn.Add(deadPlayerId);
				int num = ++_respawnRequestSeq[deadPlayerId];
				float num2 = Mathf.Max(0.25f, JuggernautPlugin.RespawnDelay.Value);
				_nextRespawnRecoveryTime[deadPlayerId] = Time.time + num2 + 6.75f + 1f;
				LogRespawn(deadPlayerId, 0, $"queued sequence={num} delay={num2:0.00}s");
				((MonoBehaviour)GameManager.Instance).StartCoroutine(SinglePlayerRespawnCoroutine(deadPlayerId, num, num2));
			}
		}

		public static void ServerRespawnWatchdogUpdate()
		{
			if (!JuggernautPlugin.Enabled.Value || JuggernautPlugin.MatchOver || (Object)(object)InstanceFinder.NetworkManager == (Object)null || !InstanceFinder.NetworkManager.IsServer || Time.time < _nextRespawnWatchdogTime)
			{
				return;
			}
			_nextRespawnWatchdogTime = Time.time + 0.5f;
			int[] array = _playersAwaitingRespawn.ToArray();
			foreach (int num in array)
			{
				if (!_respawnInProgress.Contains(num))
				{
					PlayerManager pm = FindPlayerManagerForId(num);
					float value;
					if (IsPlayerRespawnValid(num, pm, out var _))
					{
						CompleteRespawn(num, pm, "watchdog found valid player");
					}
					else if (!_nextRespawnRecoveryTime.TryGetValue(num, out value) || !(Time.time < value))
					{
						LogRespawn(num, 0, "watchdog restarting failed respawn");
						ScheduleRespawn(num);
					}
				}
			}
		}

		private static IEnumerator SinglePlayerRespawnCoroutine(int deadPlayerId, int seq, float delay)
		{
			yield return (object)new WaitForSeconds(delay);
			if (JuggernautPlugin.MatchOver || (Object)(object)GameManager.Instance == (Object)null || (Object)(object)InstanceFinder.NetworkManager == (Object)null || !InstanceFinder.NetworkManager.IsServer || !_respawnRequestSeq.TryGetValue(deadPlayerId, out var value) || value != seq)
			{
				yield break;
			}
			float gateTimeout = Time.time + 1.5f;
			while (_respawnInProgress.Contains(deadPlayerId) && Time.time < gateTimeout)
			{
				yield return null;
			}
			if (_respawnInProgress.Contains(deadPlayerId))
			{
				yield break;
			}
			_respawnInProgress.Add(deadPlayerId);
			bool spawned = false;
			PlayerManager spawnedManager = null;
			try
			{
				for (int attempt = 1; attempt <= 3; attempt++)
				{
					if (JuggernautPlugin.MatchOver)
					{
						break;
					}
					PlayerManager val = FindPlayerManagerForId(deadPlayerId);
					if ((Object)(object)val == (Object)null)
					{
						LogRespawn(deadPlayerId, attempt, "missing PlayerManager");
						yield return (object)new WaitForSeconds(0.25f);
						continue;
					}
					CleanupRespawnArtifacts(deadPlayerId);
					if (!TryInvokeRespawn(val, deadPlayerId, attempt))
					{
						yield return (object)new WaitForSeconds(0.25f);
						continue;
					}
					string failureReason = "spawn did not become valid";
					float validationDeadline = Time.time + 2f;
					while (Time.time < validationDeadline && !JuggernautPlugin.MatchOver)
					{
						if (_respawnRequestSeq.TryGetValue(deadPlayerId, out value) && value == seq)
						{
							val = FindPlayerManagerForId(deadPlayerId);
							if (IsPlayerRespawnValid(deadPlayerId, val, out failureReason))
							{
								spawned = true;
								spawnedManager = val;
								break;
							}
							yield return null;
							continue;
						}
						yield break;
					}
					if (spawned)
					{
						LogRespawn(deadPlayerId, attempt, "native respawn verified");
						break;
					}
					LogRespawn(deadPlayerId, attempt, "verify failed: " + failureReason);
					yield return (object)new WaitForSeconds(0.25f);
				}
			}
			finally
			{
				_respawnInProgress.Remove(deadPlayerId);
			}
			if (spawned)
			{
				CompleteRespawn(deadPlayerId, spawnedManager, "respawn finalized");
				yield break;
			}
			LogRespawn(deadPlayerId, 3, "respawn failed after all attempts");
			_nextRespawnRecoveryTime[deadPlayerId] = Time.time + 1f;
		}

		private static void CompleteRespawn(int playerId, PlayerManager pm, string source)
		{
			if (_playersAwaitingRespawn.Remove(playerId))
			{
				_nextRespawnRecoveryTime.Remove(playerId);
				ForcePlayerReady(pm);
				LogRespawn(playerId, 0, source);
			}
		}

		private static bool TryInvokeRespawn(PlayerManager pm, int playerId, int attempt)
		{
			if (_miCmdRespawnLogic == null || (Object)(object)pm == (Object)null)
			{
				return false;
			}
			try
			{
				_miCmdRespawnLogic.Invoke(pm, null);
				LogRespawn(playerId, attempt, "native respawn invoked");
				return true;
			}
			catch (Exception ex)
			{
				Exception ex2 = ((ex is TargetInvocationException && ex.InnerException != null) ? ex.InnerException : ex);
				LogRespawn(playerId, attempt, "native respawn failed: " + ex2.GetType().Name + " - " + ex2.Message);
				return false;
			}
		}

		private static bool IsPlayerRespawnValid(int playerId, PlayerManager pm, out string reason)
		{
			reason = "";
			if ((Object)(object)pm == (Object)null)
			{
				reason = "missing PlayerManager";
				return false;
			}
			if ((Object)(object)pm.player == (Object)null)
			{
				reason = "missing player controller";
				return false;
			}
			GameObject gameObject = ((Component)pm.player).gameObject;
			if ((Object)(object)gameObject == (Object)null || !gameObject.activeInHierarchy)
			{
				reason = "inactive player object";
				return false;
			}
			PlayerValues component = gameObject.GetComponent<PlayerValues>();
			if ((((component == null) ? ((int?)null) : component.sync___get_value_playerClient()?.PlayerId) ?? (-1)) != playerId)
			{
				reason = "player id mismatch";
				return false;
			}
			PlayerHealth component2 = gameObject.GetComponent<PlayerHealth>();
			if ((Object)(object)component2 == (Object)null)
			{
				reason = "missing PlayerHealth";
				return false;
			}
			if (component2.sync___get_value_health() <= 0f || component2.sync___get_value_isKilled())
			{
				reason = "still dead";
				return false;
			}
			NetworkObject component3 = gameObject.GetComponent<NetworkObject>();
			if ((Object)(object)component3 == (Object)null || !component3.IsSpawned)
			{
				reason = "player NetworkObject is not spawned";
				return false;
			}
			CharacterController component4 = gameObject.GetComponent<CharacterController>();
			if ((Object)(object)component4 == (Object)null || !((Collider)component4).enabled)
			{
				reason = "character controller is not ready";
				return false;
			}
			return true;
		}

		private static void ForcePlayerReady(PlayerManager pm)
		{
			if ((Object)(object)pm == (Object)null)
			{
				return;
			}
			try
			{
				pm.SetPlayerMove(true);
				if ((Object)(object)pm.player != (Object)null)
				{
					pm.player.sync___set_value_canMove(true, true);
					pm.player.startOfRound = false;
				}
				if ((Object)(object)PauseManager.Instance != (Object)null)
				{
					PauseManager.Instance.startRound = false;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = JuggernautPlugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("[Juggernaut Respawn] could not finalize player movement: " + ex.GetType().Name));
				}
			}
			GameManager instance = GameManager.Instance;
			if (instance != null)
			{
				((MonoBehaviour)instance).StartCoroutine(KeepPlayerMovable(pm, 4f));
			}
		}

		private static void CleanupRespawnArtifacts(int playerId)
		{
			try
			{
				if (_playerRagdolls.TryGetValue(playerId, out var value) && (Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
				_playerRagdolls.Remove(playerId);
				CleanupBloodAndHats();
			}
			catch
			{
			}
		}

		private static void LogRespawn(int playerId, int attempt, string message)
		{
			try
			{
				ManualLogSource log = JuggernautPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"[Juggernaut Respawn] player={playerId} attempt={attempt}: {message}");
				}
			}
			catch
			{
			}
		}

		private static IEnumerator KeepPlayerMovable(PlayerManager pm, float duration)
		{
			float end = Time.time + duration;
			while (Time.time < end)
			{
				try
				{
					if ((Object)(object)pm != (Object)null)
					{
						pm.SetPlayerMove(true);
						if ((Object)(object)pm.player != (Object)null)
						{
							pm.player.sync___set_value_canMove(true, true);
							pm.player.startOfRound = false;
						}
						if ((Object)(object)PauseManager.Instance != (Object)null)
						{
							PauseManager.Instance.startRound = false;
						}
					}
				}
				catch
				{
				}
				yield return null;
			}
		}

		private static int FindKillerId(int deadPlayerId)
		{
			PlayerHealth val = JuggernautManager.FindPlayerHealthById(deadPlayerId);
			if ((Object)(object)val == (Object)null)
			{
				return -1;
			}
			Transform val2 = val.sync___get_value_killer();
			if ((Object)(object)val2 == (Object)null)
			{
				return -1;
			}
			ClientInstance componentInParent = ((Component)val2).GetComponentInParent<ClientInstance>(true);
			if ((Object)(object)componentInParent != (Object)null)
			{
				return componentInParent.PlayerId;
			}
			PlayerValues obj = ((Component)val2).GetComponentInParent<PlayerValues>(true) ?? ((Component)val2).GetComponentInChildren<PlayerValues>(true);
			int? num = ((obj == null) ? ((int?)null) : obj.sync___get_value_playerClient()?.PlayerId);
			if (num.HasValue)
			{
				int valueOrDefault = num.GetValueOrDefault();
				if (valueOrDefault >= 0)
				{
					return valueOrDefault;
				}
			}
			GameObject val3 = null;
			ProximityMine val4 = ((Component)val2).GetComponentInParent<ProximityMine>(true) ?? ((Component)val2).GetComponentInChildren<ProximityMine>(true);
			if ((Object)(object)val4 != (Object)null)
			{
				val3 = val4.sync___get_value__rootObject();
			}
			else
			{
				Claymore val5 = ((Component)val2).GetComponentInParent<Claymore>(true) ?? ((Component)val2).GetComponentInChildren<Claymore>(true);
				if ((Object)(object)val5 != (Object)null)
				{
					val3 = val5.sync___get_value__rootObject();
				}
			}
			if ((Object)(object)val3 != (Object)null)
			{
				int ownerIdFromRootObject = GetOwnerIdFromRootObject(val3);
				if (ownerIdFromRootObject >= 0)
				{
					return ownerIdFromRootObject;
				}
			}
			return -1;
		}

		private static int GetOwnerIdFromRootObject(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return -1;
			}
			ClientInstance val = root.GetComponentInParent<ClientInstance>(true) ?? root.GetComponentInChildren<ClientInstance>(true);
			if ((Object)(object)val != (Object)null)
			{
				return val.PlayerId;
			}
			PlayerValues obj = root.GetComponentInParent<PlayerValues>(true) ?? root.GetComponentInChildren<PlayerValues>(true);
			int num = ((obj == null) ? ((int?)null) : obj.sync___get_value_playerClient()?.PlayerId) ?? (-1);
			if (num >= 0)
			{
				return num;
			}
			foreach (KeyValuePair<int, ClientInstance> playerInstance in ClientInstance.playerInstances)
			{
				try
				{
					ClientInstance value = playerInstance.Value;
					PlayerManager val2 = ((value != null) ? ((Component)value).GetComponent<PlayerManager>() : null);
					if ((Object)(object)val2 == (Object)null || !((Object)(object)val2.player != (Object)null) || (!((Object)(object)((Component)val2.player).gameObject == (Object)(object)root) && !root.transform.IsChildOf(((Component)val2.player).transform)))
					{
						continue;
					}
					return playerInstance.Key;
				}
				catch
				{
				}
			}
			return -1;
		}

		private static PlayerManager FindPlayerManagerForId(int playerId)
		{
			if (ClientInstance.playerInstances.TryGetValue(playerId, out var value) && (Object)(object)value != (Object)null)
			{
				return ((Component)value).GetComponent<PlayerManager>();
			}
			return null;
		}
	}
	public static class JuggernautSpeed
	{
		private static readonly string[] SpeedFieldNames = new string[6] { "walkSpeed", "sprintSpeed", "crouchSpeed", "slopeSpeed", "airSpeed", "sprintAirSpeed" };

		private static FieldInfo[] _fields;

		private static FirstPersonController _boostedController;

		private static float[] _baseValues;

		private static int _appliedPercent;

		private static void CacheFields()
		{
			if (_fields != null)
			{
				return;
			}
			_fields = new FieldInfo[SpeedFieldNames.Length];
			for (int i = 0; i < SpeedFieldNames.Length; i++)
			{
				_fields[i] = typeof(FirstPersonController).GetField(SpeedFieldNames[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (_fields[i] == null)
				{
					ManualLogSource log = JuggernautPlugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("[Juggernaut] speed field missing: " + SpeedFieldNames[i]));
					}
				}
			}
		}

		public static void ResetState()
		{
			_boostedController = null;
			_baseValues = null;
			_appliedPercent = 0;
		}

		public static void EnforceSpeed()
		{
			CacheFields();
			int effectiveSpeedBoostPercent = JuggernautManager.EffectiveSpeedBoostPercent;
			int num;
			object obj;
			if (effectiveSpeedBoostPercent > 0 && JuggernautManager.ModeActiveLocally() && JuggernautManager.JugPlayerId >= 0 && (Object)(object)ClientInstance.Instance != (Object)null)
			{
				num = ((ClientInstance.Instance.PlayerId == JuggernautManager.JugPlayerId) ? 1 : 0);
				if (num != 0)
				{
					obj = FindLocalController();
					goto IL_004a;
				}
			}
			else
			{
				num = 0;
			}
			obj = null;
			goto IL_004a;
			IL_004a:
			FirstPersonController val = (FirstPersonController)obj;
			if ((Object)(object)_boostedController != (Object)null && ((Object)(object)_boostedController != (Object)(object)val || _appliedPercent != effectiveSpeedBoostPercent))
			{
				RestoreBoost();
			}
			if (num == 0 || (Object)(object)val == (Object)null || (Object)(object)_boostedController == (Object)(object)val)
			{
				return;
			}
			try
			{
				_baseValues = new float[_fields.Length];
				float num2 = 1f + (float)effectiveSpeedBoostPercent / 100f;
				for (int i = 0; i < _fields.Length; i++)
				{
					if (!(_fields[i] == null))
					{
						_baseValues[i] = (float)_fields[i].GetValue(val);
						_fields[i].SetValue(val, _baseValues[i] * num2);
					}
				}
				_boostedController = val;
				_appliedPercent = effectiveSpeedBoostPercent;
				ManualLogSource log = JuggernautPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"[Juggernaut] speed boost +{effectiveSpeedBoostPercent}% applied");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = JuggernautPlugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[Juggernaut] speed boost failed: " + ex.GetType().Name));
				}
				_boostedController = null;
				_baseValues = null;
			}
		}

		private static void RestoreBoost()
		{
			try
			{
				if ((Object)(object)_boostedController != (Object)null && _baseValues != null)
				{
					for (int i = 0; i < _fields.Length; i++)
					{
						if (!(_fields[i] == null))
						{
							_fields[i].SetValue(_boostedController, _baseValues[i]);
						}
					}
				}
			}
			catch
			{
			}
			_boostedController = null;
			_baseValues = null;
			_appliedPercent = 0;
		}

		private static FirstPersonController FindLocalController()
		{
			try
			{
				ClientInstance instance = ClientInstance.Instance;
				PlayerManager val = ((instance != null) ? ((Component)instance).GetComponent<PlayerManager>() : null);
				if ((Object)(object)val?.player != (Object)null && ((Component)val.player).gameObject.activeInHierarchy)
				{
					return val.player;
				}
			}
			catch
			{
			}
			try
			{
				FirstPersonController val2 = Settings.Instance?.localPlayer;
				if ((Object)(object)val2 != (Object)null && ((Component)val2).gameObject.activeInHierarchy)
				{
					return val2;
				}
			}
			catch
			{
			}
			return null;
		}
	}
	[BepInPlugin("com.willofkabr.juggurnaught", "Juggurnaught", "1.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class JuggernautPlugin : BaseUnityPlugin
	{
		public const string PluginGUID = "com.willofkabr.juggurnaught";

		public const string PluginName = "Juggurnaught";

		public const string PluginVersion = "1.1.0";

		public const uint ModId = 774477u;

		private const string MyceliumGUID = "RugbugRedfern.MyceliumNetworking";

		private const string ModMenuGUID = "kestrel.straftat.modmenu";

		internal static ManualLogSource Log;

		private static JuggernautPlugin _instance;

		public static ConfigEntry<bool> Enabled;

		public static ConfigEntry<int> TakesToWin;

		public static ConfigEntry<int> PointsToWin;

		public static ConfigEntry<int> PointsPerSecond;

		public static ConfigEntry<int> BonusHealth;

		public static ConfigEntry<int> HealthPerKill;

		public static ConfigEntry<int> SpeedBoostPercent;

		public static ConfigEntry<float> RespawnDelay;

		public static ConfigEntry<bool> ShowHud;

		public static bool MatchOver;

		private bool _fishNetHooked;

		private float _nextOutlineTime;

		public static JuggernautPlugin Instance => _instance;

		private void Awake()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Expected O, but got Unknown
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Expected O, but got Unknown
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Expected O, but got Unknown
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			_instance = this;
			Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Enable Juggernaut mode. Only the host's setting matters for gameplay.");
			PointsToWin = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Points To Win", 100, new ConfigDescription("Points the Juggernaut must accumulate to win a take.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 1000), Array.Empty<object>()));
			TakesToWin = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Takes To Win Round", 2, new ConfigDescription("Take wins needed to win the round, like the base game. Reaching the point target wins one take.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 5), Array.Empty<object>()));
			PointsPerSecond = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Points Per Second", 5, new ConfigDescription("Points the Juggernaut earns for every second they stay alive.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50), Array.Empty<object>()));
			BonusHealth = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Juggernaut Bonus Health", 100, new ConfigDescription("Extra health granted when a player becomes the Juggernaut (in HUD health units, 100 = one full health bar). Stacks on top of their current health.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(25, 400), Array.Empty<object>()));
			HealthPerKill = ((BaseUnityPlugin)this).Config.Bind<int>("Perks", "Jug Health Per Kill", 0, new ConfigDescription("Extra health the Juggernaut gains for each kill, in HUD health units (0 = off).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 200), Array.Empty<object>()));
			SpeedBoostPercent = ((BaseUnityPlugin)this).Config.Bind<int>("Perks", "Jug Speed Boost %", 0, new ConfigDescription("Extra movement speed for the Juggernaut, as a percentage (0 = off).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			RespawnDelay = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Respawn Delay", 3f, new ConfigDescription("Seconds before a dead player respawns.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 10f), Array.Empty<object>()));
			ShowHud = ((BaseUnityPlugin)this).Config.Bind<bool>("HUD", "Show Point Counter", true, "Show the on-screen Juggernaut point counter.");
			JuggernautPatches.Apply();
			MyceliumNetwork.RegisterNetworkObject((object)this, 774477u, 0);
			SceneManager.sceneLoaded += OnSceneLoaded;
			GameObject val = new GameObject("JuggernautHud");
			val.transform.SetParent(((Component)this).transform, false);
			val.AddComponent<JuggernautHud>();
			Log.LogInfo((object)"Juggurnaught 1.1.0 loaded.");
		}

		private void OnEnable()
		{
			_instance = this;
		}

		private void OnDisable()
		{
			if ((Object)(object)_instance == (Object)(object)this)
			{
				_instance = null;
			}
		}

		private void OnDestroy()
		{
			MyceliumNetwork.DeregisterNetworkObject((object)this, 774477u, 0);
			SceneManager.sceneLoaded -= OnSceneLoaded;
			if (_fishNetHooked && (Object)(object)InstanceFinder.SceneManager != (Object)null)
			{
				InstanceFinder.SceneManager.OnLoadEnd -= OnFishNetSceneLoaded;
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			FullReset();
		}

		private void OnFishNetSceneLoaded(SceneLoadEndEventArgs args)
		{
			FullReset();
			if (Enabled.Value && (Object)(object)InstanceFinder.NetworkManager != (Object)null && InstanceFinder.NetworkManager.IsServer)
			{
				JuggernautManager.AnnounceRoundStartDelayed();
			}
		}

		internal static void FullReset()
		{
			MatchOver = false;
			JuggernautManager.ResetState();
			JuggernautOutline.ResetState();
			JuggernautSpeed.ResetState();
			JuggernautPatches.ResetState();
			JuggernautPatches.CleanupWorldEffects();
			try
			{
				if ((Object)(object)PauseManager.Instance != (Object)null)
				{
					PauseManager.Instance.startRound = false;
					PauseManager.Instance.onStartRoundScreen = false;
				}
			}
			catch
			{
			}
		}

		private void Update()
		{
			SceneManager sceneManager = InstanceFinder.SceneManager;
			if (!_fishNetHooked && (Object)(object)sceneManager != (Object)null)
			{
				sceneManager.OnLoadEnd += OnFishNetSceneLoaded;
				_fishNetHooked = true;
			}
			else if (_fishNetHooked && (Object)(object)sceneManager == (Object)null)
			{
				_fishNetHooked = false;
				FullReset();
			}
			if (Time.unscaledTime >= _nextOutlineTime)
			{
				_nextOutlineTime = Time.unscaledTime + 0.2f;
				JuggernautOutline.EnforceOutline();
				JuggernautSpeed.EnforceSpeed();
			}
			if (!Enabled.Value || (Object)(object)GameManager.Instance == (Object)null || (Object)(object)InstanceFinder.NetworkManager == (Object)null || !InstanceFinder.NetworkManager.IsServer)
			{
				return;
			}
			if (MatchOver)
			{
				JuggernautManager.ServerBroadcastTick();
				return;
			}
			JuggernautPatches.ServerRespawnWatchdogUpdate();
			JuggernautManager.ServerUpdate();
			foreach (KeyValuePair<int, ClientInstance> playerInstance in ClientInstance.playerInstances)
			{
				if (!GameManager.Instance.alivePlayers.Contains(playerInstance.Key))
				{
					GameManager.Instance.alivePlayers.Add(playerInstance.Key);
				}
			}
		}

		internal static bool TryBroadcastStateOverMycelium()
		{
			try
			{
				if (!MyceliumNetwork.InLobby)
				{
					return false;
				}
				MyceliumNetwork.RPC(774477u, "SyncJuggernautState", (ReliableType)1, new object[5]
				{
					JuggernautManager.JugPlayerId,
					JuggernautManager.EffectivePointsToWin,
					JuggernautManager.EffectiveTakesToWin,
					JuggernautManager.EffectiveSpeedBoostPercent,
					JuggernautManager.SerializePoints()
				});
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Mycelium state broadcast failed: " + ex.GetType().Name));
				}
				return false;
			}
		}

		[CustomRPC]
		public void SyncJuggernautState(int jugPlayerId, int pointsToWin, int takesToWin, int speedBoostPercent, string pointsData)
		{
			if (!((Object)(object)InstanceFinder.NetworkManager != (Object)null) || !InstanceFinder.NetworkManager.IsServer)
			{
				JuggernautManager.ApplySyncedState(jugPlayerId, pointsToWin, takesToWin, speedBoostPercent, pointsData);
			}
		}
	}
}