using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using FishNet.Connection;
using FishNet.Object;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("HowToFishPvp")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("HowToFishPvp")]
[assembly: AssemblyTitle("HowToFishPvp")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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 HowToFishPvp
{
	[HarmonyPatch]
	internal static class DeathPatch
	{
		[HarmonyPatch(typeof(PlayerUI), "ToggleDeathUI")]
		[HarmonyPrefix]
		private static bool SkipDeathUi(bool to)
		{
			if (!PvpSession.Queued)
			{
				return true;
			}
			return !to;
		}

		[HarmonyPatch(typeof(PlayerDeathCam), "EnableDeathCam")]
		[HarmonyPrefix]
		private static bool SkipDeathCam()
		{
			if (!PvpSession.Queued)
			{
				return true;
			}
			if (PvpSession.Phase == PvpPhase.MatchOver || PvpSession.Phase == PvpPhase.Fighting)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(PlayerDying), "DeathEffects")]
		[HarmonyPrefix]
		private static bool SkipHideBody()
		{
			if (!PvpSession.Queued)
			{
				return true;
			}
			if (PvpLobby.IsSkyLobby() || Time.time < PvpSession.ProtectUntil)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(PlayerDying), "LocalRespawn")]
		[HarmonyPrefix]
		private static bool SkipGiveUpRespawn()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPatch(typeof(DeadPlayer), "PrimaryInput")]
		[HarmonyPrefix]
		private static bool SkipSlapRevive()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPatch(typeof(PlayerDying), "ResurrectEffect")]
		[HarmonyPostfix]
		private static void AfterResurrect(PlayerDying __instance)
		{
			if (PvpSession.Queued && !((Object)(object)__instance == (Object)null))
			{
				Player val = null;
				try
				{
					object? value = AccessTools.Field(typeof(PlayerDying), "_player").GetValue(__instance);
					val = (Player)((value is Player) ? value : null);
				}
				catch
				{
				}
				if (!((Object)(object)val == (Object)null))
				{
					PvpController.RestorePlayerView(val);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "LocalTeleport")]
		[HarmonyPostfix]
		private static void AfterTeleport(Player __instance)
		{
			if (PvpSession.Queued && !((Object)(object)__instance == (Object)null) && !PvpController.QuietTeleport && (PvpSession.Phase != PvpPhase.Fighting || !((Object)(object)__instance.Dying != (Object)null) || !__instance.Dying.IsDead))
			{
				PvpController.RestoreVisuals(__instance);
			}
		}

		[HarmonyPatch(typeof(Player), "get_BlockInputs")]
		[HarmonyPostfix]
		private static void FreezeDuringCountdown(ref bool __result)
		{
			if (PvpSession.Queued && PvpSession.Phase == PvpPhase.Countdown && PvpSession.CountdownDisplay >= 1 && !PvpLobby.IsSkyLobby())
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch(typeof(Server), "RpcLogic___HitPlayer___2449261505")]
	internal static class HitPatch
	{
		private static void Postfix(Player __0, Player __5)
		{
			if (PvpSession.MatchRunning && PvpSession.Phase == PvpPhase.Fighting && !((Object)(object)__0 == (Object)null) && !((Object)(object)__0.Vitals == (Object)null) && __0.Vitals.Health <= 0 && !((Object)(object)__5 == (Object)null) && !((Object)(object)__5 == (Object)(object)__0))
			{
				PvpSession.EnsurePlayer(__5);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerVitals))]
	internal static class HungerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("LowerFullnessTick")]
		private static bool SkipHungerTick()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPrefix]
		[HarmonyPatch("DamageFromFullness")]
		private static bool SkipHungerDamage()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPrefix]
		[HarmonyPatch("LowerFullness")]
		private static bool SkipLoseFullness()
		{
			return !PvpSession.Queued;
		}
	}
	internal static class IslandPatch
	{
		private static float _nextClean;

		private static bool InPvp()
		{
			if (PvpSession.Queued || MenuPatch.PvpSelected)
			{
				return true;
			}
			try
			{
				if (PvpSync.LobbySaysPvp())
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				ServerSaveObject curServerSave = SaveManager.CurServerSave;
				if (curServerSave != null && !string.IsNullOrEmpty(curServerSave.Name) && curServerSave.Name.IndexOf("PVP", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		internal static void TickClean()
		{
			if (InPvp() && !(Time.unscaledTime < _nextClean))
			{
				_nextClean = Time.unscaledTime + 0.35f;
				ClearBlack();
				KillTips();
			}
		}

		internal static void ClearBlack()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				CanvasManager.ToggleBlackscreen(false, true, 0f);
			}
			catch
			{
			}
			try
			{
				object? value = AccessTools.Field(typeof(CanvasManager), "_instance").GetValue(null);
				CanvasManager val = (CanvasManager)((value is CanvasManager) ? value : null);
				if (!((Object)(object)val == (Object)null))
				{
					object? value2 = AccessTools.Field(typeof(CanvasManager), "_blackScreen").GetValue(val);
					Image val2 = (Image)((value2 is Image) ? value2 : null);
					if (!((Object)(object)val2 == (Object)null))
					{
						((Graphic)val2).color = new Color(0f, 0f, 0f, 0f);
						((Component)val2).gameObject.SetActive(false);
					}
				}
			}
			catch
			{
			}
		}

		internal static void KillTips()
		{
			try
			{
				if ((Object)(object)PlayerTutorial.Instance != (Object)null)
				{
					PlayerTutorial.Instance.SkipTutorial();
				}
			}
			catch
			{
			}
			try
			{
				PlayerTutorial instance = PlayerTutorial.Instance;
				if (!((Object)(object)instance == (Object)null))
				{
					object? value = AccessTools.Field(typeof(PlayerTutorial), "_tutorialGroup").GetValue(instance);
					CanvasGroup val = (CanvasGroup)((value is CanvasGroup) ? value : null);
					if ((Object)(object)val != (Object)null)
					{
						val.alpha = 0f;
						((Component)val).gameObject.SetActive(false);
					}
					object? value2 = AccessTools.Field(typeof(PlayerTutorial), "_tutorialHolder").GetValue(instance);
					RectTransform val2 = (RectTransform)((value2 is RectTransform) ? value2 : null);
					if ((Object)(object)val2 != (Object)null)
					{
						((Component)val2).gameObject.SetActive(false);
					}
					AccessTools.Field(typeof(PlayerTutorial), "_hide").SetValue(instance, true);
				}
			}
			catch
			{
			}
		}

		[HarmonyPatch(typeof(MainMenuManager), "CrashAnimation")]
		[HarmonyPrefix]
		private static bool SkipJoinCinematic()
		{
			if (!InPvp())
			{
				return true;
			}
			try
			{
				AccessTools.Field(typeof(MainMenuManager), "_isShowingCutscene").SetValue(null, true);
				MainMenuManager.InstantCrash();
			}
			catch
			{
			}
			try
			{
				Player.ToggleLocalPlayer(true);
			}
			catch
			{
			}
			PvpSession.EnsureQueued();
			ClearBlack();
			KillTips();
			return false;
		}

		[HarmonyPatch(typeof(MainMenuManager), "HideBoat")]
		[HarmonyPrefix]
		private static bool SkipHideBoatFade()
		{
			if (!InPvp())
			{
				return true;
			}
			try
			{
				AccessTools.Field(typeof(MainMenuManager), "_isShowingCutscene").SetValue(null, false);
			}
			catch
			{
			}
			ClearBlack();
			return false;
		}

		[HarmonyPatch(typeof(CanvasManager), "ToggleBlackscreen")]
		[HarmonyPrefix]
		private static bool SkipPvpBlackFade(bool to, ref bool instant)
		{
			if (!InPvp())
			{
				return true;
			}
			if (to)
			{
				return false;
			}
			instant = true;
			return true;
		}

		[HarmonyPatch(typeof(TutorialManager), "AddTutorial")]
		[HarmonyPrefix]
		private static bool SkipTutorial()
		{
			return !InPvp();
		}

		[HarmonyPatch(typeof(TutorialManager), "Start")]
		[HarmonyPrefix]
		private static bool SkipTutorialStart()
		{
			return !InPvp();
		}

		[HarmonyPatch(typeof(PlayerTutorial), "AddTutorial")]
		[HarmonyPrefix]
		private static bool SkipPlayerTutorial()
		{
			return !InPvp();
		}

		[HarmonyPatch(typeof(PlayerTutorial), "InitializeLocal")]
		[HarmonyPostfix]
		private static void AfterTutorialInit()
		{
			if (InPvp())
			{
				KillTips();
			}
		}

		[HarmonyPatch(typeof(OnlineIslandManager), "OnStartServer")]
		[HarmonyPostfix]
		private static void OnStartServerPostfix(OnlineIslandManager __instance)
		{
			if (!PvpSession.Queued)
			{
				return;
			}
			try
			{
				MenuPatch.ApplyPvpSaveIslands();
				PvpController.UnlockAllIslands();
				if ((Object)(object)__instance != (Object)null && ((NetworkBehaviour)__instance).IsServerInitialized)
				{
					__instance.SpawnIsland((byte)1);
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[HowToFishPvp] OnStartServer island set failed: " + ex));
			}
			ClearBlack();
			KillTips();
		}

		[HarmonyPatch(typeof(OnlineIslandManager), "OnStartClient")]
		[HarmonyPostfix]
		private static void OnStartClientPostfix()
		{
			if (!PvpSession.Queued || PvpSession.MatchRunning)
			{
				return;
			}
			KillTips();
			ClearBlack();
			try
			{
				OnlineIslandManager.ToggleTeleportPlayers(true);
				IslandManager.LoadIsland((byte)1);
				IslandManager.OnIslandChange((byte)1);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[HowToFishPvp] OnStartClient island load failed: " + ex));
			}
		}

		[HarmonyPatch(typeof(BoatManager), "TrySpawnBoat")]
		[HarmonyPrefix]
		private static bool SkipSpawnBoat()
		{
			return !InPvp();
		}

		[HarmonyPatch(typeof(BoatManager), "TryMoveBoat")]
		[HarmonyPrefix]
		private static bool SkipMoveBoat()
		{
			return !InPvp();
		}

		[HarmonyPatch(typeof(IslandManager), "OnIslandChange")]
		[HarmonyPostfix]
		private static void AfterIslandChange()
		{
			if (PvpSession.Queued)
			{
				PvpController.HideShops();
				PvpController.RestoreAllViews();
				ClearBlack();
				KillTips();
			}
		}
	}
	[HarmonyPatch]
	internal static class LobbyPatch
	{
		private static bool InSafePeriod()
		{
			if (PvpLobby.IsSkyLobby())
			{
				return true;
			}
			if (!PvpSession.Queued)
			{
				return false;
			}
			if (Time.time < PvpSession.ProtectUntil)
			{
				return true;
			}
			return PvpSession.Phase == PvpPhase.Countdown;
		}

		private static Player PlayerOf(PlayerMovement move)
		{
			if ((Object)(object)move == (Object)null)
			{
				return null;
			}
			try
			{
				object? value = AccessTools.Field(typeof(PlayerMovement), "_player").GetValue(move);
				return (Player)((value is Player) ? value : null);
			}
			catch
			{
				return null;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerVitals), "TakeDamage")]
		private static bool SkipLobbyDamage()
		{
			return !InSafePeriod();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerVitals), "LocalHit")]
		private static bool SkipLobbyLocalHit()
		{
			return !InSafePeriod();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerVitals), "TickUpdate")]
		private static bool SkipLobbyTicks()
		{
			return !InSafePeriod();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerVitals), "FireTick")]
		private static bool SkipLobbyFire()
		{
			return !InSafePeriod();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerVitals), "PoisonTick")]
		private static bool SkipLobbyPoison()
		{
			return !InSafePeriod();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerMovement), "UnderWaterCheck")]
		private static bool SkipLobbyDrown(PlayerMovement __instance)
		{
			if (PvpBoats.IsStandingOnBoat(PlayerOf(__instance)))
			{
				return false;
			}
			return !InSafePeriod();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Server), "HitPlayer")]
		private static bool SkipLobbyHit()
		{
			return !InSafePeriod();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Server), "RpcLogic___HitPlayer___2449261505")]
		private static bool SkipLobbyHitRpc()
		{
			return !InSafePeriod();
		}
	}
	internal static class MenuPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__StartPvpFromMenu;
		}

		private const string ButtonObjectName = "HowToFishPvpModeButton";

		internal static bool PvpSelected;

		private static Button _pvpButton;

		internal static void TryAttachIfNeeded()
		{
			ButtonManager manager = GetManager();
			if ((Object)(object)manager != (Object)null)
			{
				EnsurePvpButton(manager);
			}
		}

		[HarmonyPatch(typeof(ButtonManager), "Start")]
		[HarmonyPostfix]
		private static void StartPostfix(ButtonManager __instance)
		{
			try
			{
				EnsurePvpButton(__instance);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[HowToFishPvp] Menu setup failed: " + ex));
			}
		}

		[HarmonyPatch(typeof(ButtonManager), "ToggleCreateServerButton")]
		[HarmonyPostfix]
		private static void KeepPvpClickable()
		{
			if ((Object)(object)_pvpButton != (Object)null)
			{
				((Selectable)_pvpButton).interactable = true;
				PaintEnabled(_pvpButton);
			}
		}

		[HarmonyPatch(typeof(ButtonManager), "CreateNewServer")]
		[HarmonyPrefix]
		private static void CreatePrefix(ButtonManager __instance)
		{
			if (PvpSelected)
			{
				QueuePvp(__instance);
			}
		}

		[HarmonyPatch(typeof(SaveManager), "CreateServer")]
		[HarmonyPostfix]
		private static void CreateServerPostfix()
		{
			if (PvpSession.Queued)
			{
				ApplyPvpSaveIslands();
			}
		}

		internal static void QueuePvp(ButtonManager manager)
		{
			PvpSelected = true;
			PvpSession.Queued = true;
			PvpSession.ResetMatch();
			PvpSession.Phase = PvpPhase.WaitingForPlayers;
			PvpSession.Banner = "PVP MODE";
			PvpSession.SubBanner = "Invite friends, then wait in-world";
			ApplyPvpSaveIslands();
			object? value = AccessTools.Field(typeof(ButtonManager), "_serverNameInputField").GetValue(manager);
			TMP_InputField val = (TMP_InputField)((value is TMP_InputField) ? value : null);
			if ((Object)(object)val != (Object)null && string.IsNullOrEmpty(val.text))
			{
				val.text = "PVP Arena";
			}
			AccessTools.Field(typeof(ButtonManager), "_useSteam").SetValue(manager, true);
			AccessTools.Field(typeof(ButtonManager), "_isPublic").SetValue(manager, false);
		}

		internal static void ApplyPvpSaveIslands()
		{
			ServerSaveObject curServerSave = SaveManager.CurServerSave;
			if (curServerSave != null)
			{
				curServerSave.SpawnedIsland = 1;
				curServerSave.MaxIsland = byte.MaxValue;
			}
		}

		internal static void StartPvpFromMenu()
		{
			ButtonManager manager = GetManager();
			if (!((Object)(object)manager == (Object)null))
			{
				QueuePvp(manager);
				object? value = AccessTools.Field(typeof(ButtonManager), "_serverNameInputField").GetValue(manager);
				TMP_InputField val = (TMP_InputField)((value is TMP_InputField) ? value : null);
				if ((Object)(object)val != (Object)null)
				{
					val.text = "PVP Arena";
				}
				AccessTools.Method(typeof(ButtonManager), "ToggleCreateServerButton", (Type[])null, (Type[])null).Invoke(manager, new object[1] { true });
				manager.CreateNewServer();
			}
		}

		private static ButtonManager GetManager()
		{
			object? value = AccessTools.Field(typeof(ButtonManager), "_instance").GetValue(null);
			ButtonManager val = (ButtonManager)((value is ButtonManager) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				val = Object.FindObjectOfType<ButtonManager>();
			}
			return val;
		}

		private static void EnsurePvpButton(ButtonManager manager)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			object? value = AccessTools.Field(typeof(ButtonManager), "_createServerButton").GetValue(manager);
			Button val = (Button)((value is Button) ? value : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Transform parent = ((Component)val).transform.parent;
			if ((Object)(object)parent == (Object)null)
			{
				return;
			}
			Transform val2 = parent.Find("HowToFishPvpModeButton");
			if ((Object)(object)val2 != (Object)null)
			{
				_pvpButton = ((Component)val2).GetComponent<Button>();
				BindHostButtons(val, _pvpButton);
				return;
			}
			_pvpButton = Object.Instantiate<Button>(val, parent);
			((Object)_pvpButton).name = "HowToFishPvpModeButton";
			((Component)_pvpButton).gameObject.SetActive(true);
			((Selectable)_pvpButton).interactable = true;
			_pvpButton.onClick = new ButtonClickedEvent();
			ButtonClickedEvent onClick = _pvpButton.onClick;
			object obj = <>O.<0>__StartPvpFromMenu;
			if (obj == null)
			{
				UnityAction val3 = StartPvpFromMenu;
				<>O.<0>__StartPvpFromMenu = val3;
				obj = (object)val3;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			StripLocalization(((Component)_pvpButton).gameObject);
			BindHostButtons(val, _pvpButton);
		}

		private static void BindHostButtons(Button create, Button pvp)
		{
			//IL_0046: 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)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)create == (Object)null) && !((Object)(object)pvp == (Object)null))
			{
				RectTransform component = ((Component)create).GetComponent<RectTransform>();
				RectTransform component2 = ((Component)pvp).GetComponent<RectTransform>();
				LayoutElement val = ((Component)component2).GetComponent<LayoutElement>();
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)pvp).gameObject.AddComponent<LayoutElement>();
				}
				val.ignoreLayout = true;
				component2.anchorMin = component.anchorMin;
				component2.anchorMax = component.anchorMax;
				component2.pivot = component.pivot;
				component2.sizeDelta = component.sizeDelta;
				component2.offsetMin = component.offsetMin;
				component2.offsetMax = component.offsetMax;
				PvpHostButtons pvpHostButtons = ((Component)pvp).GetComponent<PvpHostButtons>();
				if ((Object)(object)pvpHostButtons == (Object)null)
				{
					pvpHostButtons = ((Component)pvp).gameObject.AddComponent<PvpHostButtons>();
				}
				pvpHostButtons.CreateRt = component;
				pvpHostButtons.PvpRt = component2;
				if ((Object)(object)((Component)pvp).GetComponent<PvpButtonLabel>() == (Object)null)
				{
					((Component)pvp).gameObject.AddComponent<PvpButtonLabel>();
				}
				ApplyPvpLabel(((Component)pvp).gameObject);
				PaintEnabled(pvp);
			}
		}

		private static void PaintEnabled(Button btn)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)btn == (Object)null)
			{
				return;
			}
			((Selectable)btn).interactable = true;
			ColorBlock colors = ((Selectable)btn).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = Color.white;
			((ColorBlock)(ref colors)).selectedColor = Color.white;
			((ColorBlock)(ref colors)).disabledColor = Color.white;
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((Selectable)btn).colors = colors;
			Image[] componentsInChildren = ((Component)btn).GetComponentsInChildren<Image>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (!((Object)(object)componentsInChildren[i] == (Object)null))
				{
					string text = ((Object)((Component)componentsInChildren[i]).gameObject).name ?? "";
					if (text.IndexOf("outline", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("border", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						((Graphic)componentsInChildren[i]).color = Color.white;
					}
				}
			}
		}

		internal static void StripLocalization(GameObject go)
		{
			Component[] componentsInChildren = go.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !(val is Transform) && !(val is CanvasRenderer))
				{
					string text = ((object)val).GetType().FullName ?? "";
					if (text.IndexOf("Localize", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Localization", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						Object.Destroy((Object)(object)val);
					}
				}
			}
		}

		internal static void ApplyPvpLabel(GameObject go)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)go == (Object)null))
			{
				TMP_Text[] componentsInChildren = go.GetComponentsInChildren<TMP_Text>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].text = "PVP MODE";
					((Graphic)componentsInChildren[i]).color = Color.white;
					componentsInChildren[i].alignment = (TextAlignmentOptions)514;
				}
			}
		}
	}
	internal sealed class PvpButtonLabel : MonoBehaviour
	{
		private void LateUpdate()
		{
			MenuPatch.ApplyPvpLabel(((Component)this).gameObject);
		}
	}
	internal sealed class PvpHostButtons : MonoBehaviour
	{
		internal RectTransform CreateRt;

		internal RectTransform PvpRt;

		private Vector2 _layoutPos;

		private int _appliedFrame = -1;

		private const float CreateDown = 8f;

		private const float BothDown = 16f;

		private void OnEnable()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			Canvas.willRenderCanvases += new WillRenderCanvases(AfterCanvas);
		}

		private void OnDisable()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			Canvas.willRenderCanvases -= new WillRenderCanvases(AfterCanvas);
		}

		private void LateUpdate()
		{
			MenuPatch.ApplyPvpLabel(((Component)this).gameObject);
		}

		private void AfterCanvas()
		{
			PlacePair();
		}

		private void PlacePair()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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)
			//IL_00d1: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)CreateRt == (Object)null) && !((Object)(object)PvpRt == (Object)null))
			{
				((Component)this).gameObject.SetActive(true);
				int frameCount = Time.frameCount;
				if (_appliedFrame != frameCount)
				{
					_layoutPos = CreateRt.anchoredPosition;
					_appliedFrame = frameCount;
				}
				PvpRt.anchorMin = CreateRt.anchorMin;
				PvpRt.anchorMax = CreateRt.anchorMax;
				PvpRt.pivot = CreateRt.pivot;
				PvpRt.sizeDelta = CreateRt.sizeDelta;
				Rect rect = CreateRt.rect;
				float num = ((Rect)(ref rect)).height;
				if (num < 8f)
				{
					num = 42f;
				}
				CreateRt.anchoredPosition = _layoutPos + new Vector2(0f, -24f);
				PvpRt.anchoredPosition = _layoutPos + new Vector2(0f, num + 2f - 16f);
			}
		}
	}
	[BepInPlugin("mox.howtofish.pvp", "How to Fish PVP Mode", "1.0.1")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "mox.howtofish.pvp";

		public const string PluginName = "How to Fish PVP Mode";

		public const string PluginVersion = "1.0.1";

		internal static Plugin Instance;

		internal static Harmony Harmony;

		private void Awake()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			Instance = this;
			Harmony = new Harmony("mox.howtofish.pvp");
			PatchSafe(typeof(MenuPatch));
			PatchSafe(typeof(IslandPatch));
			PatchSafe(typeof(HitPatch));
			PatchSafe(typeof(ShopPatch));
			PatchSafe(typeof(HungerPatch));
			PatchSafe(typeof(DeathPatch));
			PatchSafe(typeof(LobbyPatch));
			PatchSafe(typeof(PvpSync));
			PatchSafe(typeof(PvpGrab));
			PatchSafe(typeof(PvpFloodPatch));
			PatchSafe(typeof(PvpBoom));
			PatchSafe(typeof(PvpSpike));
			PatchSafe(typeof(PvpCloak));
			PatchSafe(typeof(PvpBoats));
			((Component)this).gameObject.AddComponent<PvpController>();
			((Component)this).gameObject.AddComponent<PvpHud>();
			((Component)this).gameObject.AddComponent<PvpGrab>();
			((Component)this).gameObject.AddComponent<PvpCloakDriver>();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"PVP Mode loaded. PVP MODE sits next to Create on New Game.");
		}

		private void PatchSafe(Type type)
		{
			try
			{
				Harmony.CreateClassProcessor(type).Patch();
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Failed to patch " + type.Name + ": " + ex));
			}
		}
	}
	internal enum ArenaMap
	{
		None,
		Benches,
		Towers,
		Floaters,
		Tightrope,
		Stairs,
		Hole,
		Pillars,
		Spinner,
		House,
		Tiny,
		Bridge,
		Crates,
		Colosseum,
		FallGrid,
		FallRing,
		FallLanes,
		FallSteps,
		Seesaw,
		Movers,
		MoveFerry,
		MoveCircle,
		Elevators,
		DropPath,
		DualSpin,
		Windmill,
		Cross,
		OceanBridge
	}
	internal static class PvpArena
	{
		private struct PropKit
		{
			public GameObject Src;

			public Mesh Mesh;

			public Material[] Mats;

			public bool Wood;
		}

		private const float SkyAboveWater = 26f;

		private static GameObject _root;

		private static ArenaMap _built;

		private static int _layer;

		private static float _yaw;

		private static ArenaMap[] _plan;

		private static int _planSeed;

		private static readonly List<Transform> _spawns = new List<Transform>();

		private static readonly List<Renderer> _hiddenRends = new List<Renderer>();

		private static readonly List<Collider> _hiddenCols = new List<Collider>();

		private static readonly List<Texture> _stoneTex = new List<Texture>();

		private static readonly List<Texture> _woodTex = new List<Texture>();

		private static readonly Dictionary<int, Material> _clones = new Dictionary<int, Material>();

		private static int _surfI;

		private static int _propI;

		private static Shader _lit;

		private static readonly List<PropKit> _woodProps = new List<PropKit>();

		private static readonly List<PropKit> _rockProps = new List<PropKit>();

		internal static bool IsActive
		{
			get
			{
				if ((Object)(object)_root != (Object)null && _built != ArenaMap.None)
				{
					return _built != ArenaMap.Benches;
				}
				return false;
			}
		}

		internal static ArenaMap Built => _built;

		internal static void Roll(int seed)
		{
			_planSeed = seed;
			int num = 20;
			_plan = new ArenaMap[num];
			Random random = new Random(seed);
			List<ArenaMap> list = new List<ArenaMap>();
			list.Add(ArenaMap.Movers);
			list.Add(ArenaMap.FallGrid);
			list.Add(ArenaMap.FallRing);
			list.Add(ArenaMap.FallLanes);
			list.Add(ArenaMap.FallSteps);
			list.Add(ArenaMap.MoveFerry);
			list.Add(ArenaMap.MoveCircle);
			list.Add(ArenaMap.OceanBridge);
			Shuffle(list, random);
			List<ArenaMap> list2 = new List<ArenaMap>();
			for (int i = 0; i < list.Count; i++)
			{
				list2.Add(list[i]);
			}
			while (list2.Count < num)
			{
				list2.Add(ArenaMap.None);
			}
			int num2 = list2.IndexOf(ArenaMap.None);
			if (num2 > 0)
			{
				ArenaMap value = list2[0];
				list2[0] = list2[num2];
				list2[num2] = value;
			}
			for (int num3 = list2.Count - 1; num3 >= 2; num3--)
			{
				int index = random.Next(1, num3 + 1);
				ArenaMap value2 = list2[num3];
				list2[num3] = list2[index];
				list2[index] = value2;
			}
			for (int j = 0; j < num; j++)
			{
				_plan[j] = list2[j];
			}
			for (int k = 1; k < num; k++)
			{
				if (_plan[k] == ArenaMap.OceanBridge)
				{
					ArenaMap arenaMap = _plan[1];
					_plan[1] = _plan[k];
					_plan[k] = arenaMap;
					break;
				}
			}
			Debug.Log((object)("[HowToFishPvp] Map plan seed=" + seed + " " + PlanLine()));
		}

		internal static void ClearPlan()
		{
			_plan = null;
			_planSeed = 0;
		}

		internal static ArenaMap ForRound(int round)
		{
			if (PvpSession.MapSeed != 0 && (_plan == null || _planSeed != PvpSession.MapSeed))
			{
				Roll(PvpSession.MapSeed);
			}
			if (_plan == null)
			{
				return ArenaMap.None;
			}
			int num = round - 1;
			if (num < 0 || num >= _plan.Length)
			{
				return ArenaMap.None;
			}
			return _plan[num];
		}

		internal static string Title(ArenaMap map)
		{
			return map switch
			{
				ArenaMap.Benches => "Benches", 
				ArenaMap.Towers => "Towers", 
				ArenaMap.Floaters => "Floaters", 
				ArenaMap.Tightrope => "Tightrope", 
				ArenaMap.Stairs => "Stairs", 
				ArenaMap.Hole => "The Hole", 
				ArenaMap.Pillars => "Pillars", 
				ArenaMap.Spinner => "Spinner", 
				ArenaMap.House => "House", 
				ArenaMap.Tiny => "Tiny", 
				ArenaMap.Bridge => "Bridge", 
				ArenaMap.Crates => "Crates", 
				ArenaMap.Colosseum => "Colosseum", 
				ArenaMap.FallGrid => "Falling Floors", 
				ArenaMap.FallRing => "Falling Ring", 
				ArenaMap.FallLanes => "Falling Lanes", 
				ArenaMap.FallSteps => "Falling Steps", 
				ArenaMap.Seesaw => "Seesaw", 
				ArenaMap.Movers => "Movers", 
				ArenaMap.MoveFerry => "Ferries", 
				ArenaMap.MoveCircle => "Orbit", 
				ArenaMap.Elevators => "Elevators", 
				ArenaMap.DropPath => "Drop Path", 
				ArenaMap.DualSpin => "Twin Spinners", 
				ArenaMap.Windmill => "Windmill", 
				ArenaMap.Cross => "Cross", 
				ArenaMap.OceanBridge => "Docks", 
				_ => "", 
			};
		}

		internal static bool NeedsSkyArena(int round)
		{
			return ForRound(round) != ArenaMap.None;
		}

		internal static bool TryGetSpawn(out Vector3 pos, out float yaw)
		{
			return TryGetSlot(0, 1, out pos, out yaw);
		}

		internal static bool TryGetSlot(int slot, int count, out Vector3 pos, out float yaw)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: 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_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			pos = Vector3.zero;
			yaw = _yaw;
			if (!IsActive || _spawns.Count == 0)
			{
				return false;
			}
			if (count < 1)
			{
				count = 1;
			}
			int count2 = _spawns.Count;
			int num = ((count2 != 1) ? Mathf.RoundToInt(Mathf.Clamp01((float)slot / Mathf.Max(1f, (float)count - 1f)) * (float)(count2 - 1)) : 0);
			if (num < 0)
			{
				num = 0;
			}
			if (num >= count2)
			{
				num = count2 - 1;
			}
			if ((Object)(object)_spawns[num] == (Object)null)
			{
				return false;
			}
			pos = _spawns[num].position;
			if (count2 >= 2 && (Object)(object)_spawns[0] != (Object)null && (Object)(object)_spawns[count2 - 1] != (Object)null)
			{
				Vector3 val = ((num < count2 / 2) ? _spawns[count2 - 1].position : _spawns[0].position) - pos;
				val.y = 0f;
				if (((Vector3)(ref val)).sqrMagnitude > 0.01f)
				{
					yaw = Mathf.Atan2(val.x, val.z) * 57.29578f;
				}
			}
			return true;
		}

		internal static bool TryRandomDrop(out Vector3 pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			pos = Vector3.zero;
			if (!IsActive || (Object)(object)_root == (Object)null)
			{
				return false;
			}
			Collider[] componentsInChildren = _root.GetComponentsInChildren<Collider>();
			int num = 0;
			try
			{
				num = LayerMask.op_Implicit(GameInfo.LevelLayer);
			}
			catch
			{
			}
			try
			{
				num |= LayerMask.op_Implicit(GameInfo.CanJumpOnLayers);
			}
			catch
			{
			}
			if (num == 0)
			{
				num = -5;
			}
			if (componentsInChildren != null && componentsInChildren.Length != 0)
			{
				RaycastHit val2 = default(RaycastHit);
				for (int i = 0; i < 14; i++)
				{
					Collider val = componentsInChildren[Random.Range(0, componentsInChildren.Length)];
					if (!((Object)(object)val == (Object)null))
					{
						Bounds bounds = val.bounds;
						if (Physics.Raycast(new Vector3(Random.Range(((Bounds)(ref bounds)).min.x, ((Bounds)(ref bounds)).max.x), ((Bounds)(ref bounds)).max.y + 2.4f, Random.Range(((Bounds)(ref bounds)).min.z, ((Bounds)(ref bounds)).max.z)), Vector3.down, ref val2, 10f, num, (QueryTriggerInteraction)1) && !((Object)(object)((RaycastHit)(ref val2)).transform == (Object)null) && ((RaycastHit)(ref val2)).transform.IsChildOf(_root.transform))
						{
							pos = ((RaycastHit)(ref val2)).point;
							return true;
						}
					}
				}
			}
			if (_spawns.Count == 0)
			{
				return false;
			}
			int index = Random.Range(0, _spawns.Count);
			if ((Object)(object)_spawns[index] == (Object)null)
			{
				return false;
			}
			pos = _spawns[index].position;
			return true;
		}

		internal static void Destroy()
		{
			PvpBoats.Wipe();
			RestoreIsland();
			_spawns.Clear();
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
			}
			_root = null;
			_built = ArenaMap.None;
		}

		internal static void AddSpawn(Transform mark)
		{
			if ((Object)(object)mark != (Object)null && !_spawns.Contains(mark))
			{
				_spawns.Add(mark);
			}
		}

		internal unsafe static bool Build(ArenaMap map, int playerCount)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Destroy();
			if (map == ArenaMap.None || map == ArenaMap.Benches)
			{
				return false;
			}
			HarvestMats();
			_layer = FirstJumpLayer();
			if (!TryIslandSpawn(out var pos, out var yaw))
			{
				pos = ((!((Object)(object)Player.LocalPlayer != (Object)null) || !((Object)(object)Player.LocalPlayer.Transform != (Object)null)) ? Vector3.zero : Player.LocalPlayer.Transform.position);
			}
			_yaw = yaw;
			float num = 0f;
			try
			{
				num = WaterManager.GetWaterHeight(pos);
			}
			catch
			{
				try
				{
					num = WaterManager.WaterHeight;
				}
				catch
				{
				}
			}
			Vector3 val = FindOpenWater(pos, num);
			Vector3 position = ((map == ArenaMap.OceanBridge) ? new Vector3(val.x, num, val.z) : new Vector3(val.x, num + 26f, val.z));
			_root = new GameObject("HowToFishPvpArena");
			_root.layer = _layer;
			try
			{
				_root.tag = "Level";
			}
			catch
			{
			}
			_root.transform.position = position;
			MoveToIslandScene(_root);
			switch (map)
			{
			case ArenaMap.Towers:
				BuildTowers();
				break;
			case ArenaMap.Floaters:
				BuildFloaters();
				break;
			case ArenaMap.Tightrope:
				BuildTightrope();
				break;
			case ArenaMap.Stairs:
				BuildStairs();
				break;
			case ArenaMap.Hole:
				BuildHole();
				break;
			case ArenaMap.Pillars:
				BuildPillars();
				break;
			case ArenaMap.Spinner:
				BuildSpinner();
				break;
			case ArenaMap.House:
				BuildHouse();
				break;
			case ArenaMap.Tiny:
				BuildTiny();
				break;
			case ArenaMap.Bridge:
				BuildBridge();
				break;
			case ArenaMap.Crates:
				BuildCrates();
				break;
			case ArenaMap.Colosseum:
				BuildColosseum();
				break;
			case ArenaMap.FallGrid:
				BuildFallGrid();
				break;
			case ArenaMap.FallRing:
				BuildFallRing();
				break;
			case ArenaMap.FallLanes:
				BuildFallLanes();
				break;
			case ArenaMap.FallSteps:
				BuildFallSteps();
				break;
			case ArenaMap.Seesaw:
				BuildSeesaw();
				break;
			case ArenaMap.Movers:
				BuildMovers();
				break;
			case ArenaMap.MoveFerry:
				BuildMoveFerry();
				break;
			case ArenaMap.MoveCircle:
				BuildMoveCircle();
				break;
			case ArenaMap.Elevators:
				BuildElevators();
				break;
			case ArenaMap.DropPath:
				BuildDropPath();
				break;
			case ArenaMap.DualSpin:
				BuildDualSpin();
				break;
			case ArenaMap.Windmill:
				BuildWindmill();
				break;
			case ArenaMap.Cross:
				BuildCross();
				break;
			case ArenaMap.OceanBridge:
				BuildOceanBridge();
				break;
			}
			HideIsland();
			Physics.SyncTransforms();
			_built = map;
			Debug.Log((object)("[HowToFishPvp] Arena " + map.ToString() + " rocks=" + _rockProps.Count + " wood=" + _woodProps.Count + " at " + ((object)(*(Vector3*)(&position))/*cast due to .constrained prefix*/).ToString()));
			return true;
		}

		private static void BuildTowers()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			Stack(-7f);
			Stack(7f);
			Box(new Vector3(-2.3f, 3.25f, 0f), new Vector3(2.6f, 0.35f, 0.75f), wood: true);
			Box(new Vector3(2.3f, 3.25f, 0f), new Vector3(2.6f, 0.35f, 0.75f), wood: true);
			Box(new Vector3(0f, 1.1f, 4.2f), new Vector3(2.4f, 0.5f, 2.4f), wood: false);
			Box(new Vector3(0f, 1.1f, -4.2f), new Vector3(2.4f, 0.5f, 2.4f), wood: false);
			Mark(new Vector3(-7f, 6.2f, 0f));
			Mark(new Vector3(7f, 6.2f, 0f));
		}

		private static void Stack(float x)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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)
			Box(new Vector3(x, 0.4f, 0f), new Vector3(5f, 0.8f, 5f), wood: false);
			Box(new Vector3(x, 3.15f, 0f), new Vector3(3.6f, 0.7f, 3.6f), wood: false);
			Box(new Vector3(x, 5.7f, 0f), new Vector3(2.8f, 0.65f, 2.8f), wood: false);
		}

		private static void BuildFloaters()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			Box(new Vector3(-8.5f, 0.4f, -3.5f), new Vector3(2.6f, 0.7f, 2.6f), wood: false);
			Box(new Vector3(-4f, 1.6f, 4.2f), new Vector3(2.2f, 0.55f, 2.2f), wood: true);
			Box(new Vector3(0f, 0.35f, 0f), new Vector3(3.4f, 0.7f, 3.4f), wood: false);
			Box(new Vector3(5.5f, 2.3f, -5f), new Vector3(2.3f, 0.55f, 2.3f), wood: false);
			Box(new Vector3(7.2f, 0.45f, 3.2f), new Vector3(2.8f, 0.7f, 2.8f), wood: false);
			Box(new Vector3(-6.2f, 3.6f, 1.2f), new Vector3(1.9f, 0.5f, 1.9f), wood: true);
			Box(new Vector3(2.2f, 4.4f, 6f), new Vector3(2.1f, 0.5f, 2.1f), wood: false);
			Box(new Vector3(-1.2f, 2.9f, -7.2f), new Vector3(2.2f, 0.5f, 2.2f), wood: true);
			Box(new Vector3(8f, 3.2f, -1f), new Vector3(1.8f, 0.5f, 1.8f), wood: false);
			Box(new Vector3(0f, 5.6f, 0f), new Vector3(1.7f, 0.45f, 1.7f), wood: false);
			Mark(new Vector3(-8.5f, 0.85f, -3.5f));
			Mark(new Vector3(7.2f, 0.9f, 3.2f));
		}

		private static void BuildTightrope()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			Box(new Vector3(0f, 0.22f, 0f), new Vector3(18f, 0.44f, 0.62f), wood: true);
			Box(new Vector3(-9.2f, 0.45f, 0f), new Vector3(2.6f, 0.9f, 2.6f), wood: false);
			Box(new Vector3(9.2f, 0.45f, 0f), new Vector3(2.6f, 0.9f, 2.6f), wood: false);
			Box(new Vector3(0f, 0.3f, 3.6f), new Vector3(1.9f, 0.45f, 1.9f), wood: false);
			Box(new Vector3(0f, 0.3f, -3.6f), new Vector3(1.9f, 0.45f, 1.9f), wood: false);
			Box(new Vector3(-4.5f, 1.8f, 0f), new Vector3(1.5f, 0.35f, 1.5f), wood: true);
			Box(new Vector3(4.5f, 1.8f, 0f), new Vector3(1.5f, 0.35f, 1.5f), wood: true);
			Mark(new Vector3(-9.2f, 1f, 0f));
			Mark(new Vector3(9.2f, 1f, 0f));
		}

		private static void BuildStairs()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < 7; i++)
			{
				float num = (float)i * 2.55f - 7.6f;
				float num2 = 0.35f + (float)i * 0.85f;
				Box(new Vector3(num, num2, 0f), new Vector3(3.1f, 0.55f, 3.2f), i % 2 == 0);
			}
			Box(new Vector3(-7.6f, 0.9f, 4.2f), new Vector3(2.4f, 0.5f, 2.4f), wood: false);
			Box(new Vector3(7.6f, 5.8f, -4.2f), new Vector3(2.4f, 0.5f, 2.4f), wood: false);
			Mark(new Vector3(-7.6f, 0.75f, 0f));
			Mark(new Vector3(7.7f, 5.8f, 0f));
		}

		private static void BuildHole()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			Box(new Vector3(0f, 0.4f, 6.2f), new Vector3(12.4f, 0.7f, 2.5f), wood: false);
			Box(new Vector3(0f, 0.4f, -6.2f), new Vector3(12.4f, 0.7f, 2.5f), wood: false);
			Box(new Vector3(6.2f, 0.4f, 0f), new Vector3(2.5f, 0.7f, 9.9f), wood: false);
			Box(new Vector3(-6.2f, 0.4f, 0f), new Vector3(2.5f, 0.7f, 9.9f), wood: false);
			Box(new Vector3(4.4f, 2f, 4.4f), new Vector3(2f, 0.5f, 2f), wood: true);
			Box(new Vector3(-4.4f, 2f, -4.4f), new Vector3(2f, 0.5f, 2f), wood: true);
			Box(new Vector3(-4.4f, 2f, 4.4f), new Vector3(2f, 0.5f, 2f), wood: false);
			Box(new Vector3(4.4f, 2f, -4.4f), new Vector3(2f, 0.5f, 2f), wood: false);
			Mark(new Vector3(0f, 0.85f, 6.2f));
			Mark(new Vector3(0f, 0.85f, -6.2f));
		}

		private static void BuildPillars()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			Pillar(new Vector3(-7.2f, 0f, -5f), 4f);
			Pillar(new Vector3(-2.2f, 0f, 4.4f), 6.2f);
			Pillar(new Vector3(6.4f, 0f, 5.2f), 3.2f);
			Pillar(new Vector3(7f, 0f, -4.2f), 5f);
			Pillar(new Vector3(0f, 0f, 0f), 8f);
			Pillar(new Vector3(-5.2f, 0f, 1.6f), 2.4f);
			Pillar(new Vector3(3f, 0f, -6.4f), 4.4f);
			Mark(new Vector3(-7.2f, 4.1f, -5f));
			Mark(new Vector3(6.4f, 3.3f, 5.2f));
		}

		private static void Pillar(Vector3 basePos, float h)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			Box(new Vector3(basePos.x, h * 0.5f, basePos.z), new Vector3(1.85f, h, 1.85f), wood: false);
		}

		private static void BuildSpinner()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0066: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = MakeSpin(Vector3.zero, 22f, Vector3.up);
			BoxOn(obj.transform, Vector3.zero, new Vector3(3.2f, 0.8f, 3.2f), wood: false);
			BoxOn(obj.transform, Vector3.zero, new Vector3(16f, 0.65f, 2.3f), wood: true);
			BoxOn(obj.transform, Vector3.zero, new Vector3(2.3f, 0.65f, 16f), wood: true);
			MarkOn(obj.transform, new Vector3(-6.5f, 0.55f, 0f));
			MarkOn(obj.transform, new Vector3(6.5f, 0.55f, 0f));
		}

		private static void BuildHouse()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			Box(new Vector3(0f, 0.4f, 0f), new Vector3(14f, 0.8f, 10f), wood: false);
			Box(new Vector3(-6.8f, 2.5f, 0f), new Vector3(0.4f, 4.2f, 10f), wood: true);
			Box(new Vector3(6.8f, 2.5f, 0f), new Vector3(0.4f, 4.2f, 10f), wood: true);
			Box(new Vector3(0f, 2.5f, -4.8f), new Vector3(13.6f, 4.2f, 0.4f), wood: true);
			Box(new Vector3(-2.2f, 1.15f, 1.2f), new Vector3(2.2f, 1.5f, 0.55f), wood: false);
			Box(new Vector3(2.6f, 1.05f, -1.4f), new Vector3(2.5f, 1.3f, 0.55f), wood: false);
			Box(new Vector3(0f, 0.95f, -2.8f), new Vector3(2f, 1.1f, 1.6f), wood: false);
			Mark(new Vector3(-5.2f, 0.9f, 2.6f));
			Mark(new Vector3(5.2f, 0.9f, 2.6f));
		}

		private static void BuildTiny()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			Box(new Vector3(0f, 0.35f, 0f), new Vector3(2.35f, 0.7f, 2.35f), wood: false);
			Mark(new Vector3(-0.55f, 0.8f, 0f));
			Mark(new Vector3(0.55f, 0.8f, 0f));
		}

		private static void BuildBridge()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			Box(new Vector3(-8.2f, 0.5f, 0f), new Vector3(5.6f, 1f, 5.6f), wood: false);
			Box(new Vector3(8.2f, 0.5f, 0f), new Vector3(5.6f, 1f, 5.6f), wood: false);
			Box(new Vector3(-3.4f, 0.32f, 0.95f), new Vector3(5.2f, 0.38f, 0.62f), wood: true);
			Box(new Vector3(3.4f, 0.32f, 0.95f), new Vector3(5.2f, 0.38f, 0.62f), wood: true);
			Box(new Vector3(0f, 0.32f, -0.95f), new Vector3(11.4f, 0.35f, 0.55f), wood: true);
			Box(new Vector3(0f, 2.4f, 0f), new Vector3(1.8f, 0.4f, 1.8f), wood: false);
			Mark(new Vector3(-8.2f, 1.1f, 0f));
			Mark(new Vector3(8.2f, 1.1f, 0f));
		}

		private static void BuildCrates()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			float num = 1.9f;
			for (int i = 0; i < 5; i++)
			{
				Box(new Vector3((float)(i - 2) * num, num * 0.5f, 0f), new Vector3(num, num, num), wood: true);
			}
			for (int j = 0; j < 3; j++)
			{
				Box(new Vector3((float)(j - 1) * num, num * 1.5f, 0f), new Vector3(num, num, num), j == 1);
			}
			Box(new Vector3(0f, num * 2.5f, 0f), new Vector3(num, num, num), wood: false);
			Box(new Vector3(-5.6f, 0.7f, 3.4f), new Vector3(2.2f, 1.4f, 2.2f), wood: false);
			Box(new Vector3(5.6f, 0.7f, -3.4f), new Vector3(2.2f, 1.4f, 2.2f), wood: false);
			Box(new Vector3(0f, 0.4f, 4.6f), new Vector3(2.4f, 0.8f, 2.4f), wood: false);
			Box(new Vector3(0f, 0.4f, -4.6f), new Vector3(2.4f, 0.8f, 2.4f), wood: false);
			Mark(new Vector3(-3.8f, num + 0.15f, 0f));
			Mark(new Vector3(3.8f, num + 0.15f, 0f));
		}

		private static void BuildColosseum()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			Box(new Vector3(0f, 0.4f, 8.4f), new Vector3(14f, 0.75f, 2.6f), wood: false);
			Box(new Vector3(0f, 0.4f, -8.4f), new Vector3(14f, 0.75f, 2.6f), wood: false);
			Box(new Vector3(8.4f, 0.4f, 0f), new Vector3(2.6f, 0.75f, 14f), wood: false);
			Box(new Vector3(-8.4f, 0.4f, 0f), new Vector3(2.6f, 0.75f, 14f), wood: false);
			Box(new Vector3(0f, 0.45f, 0f), new Vector3(10f, 0.7f, 2.2f), wood: true);
			Box(new Vector3(0f, 0.45f, 0f), new Vector3(2.2f, 0.7f, 10f), wood: true);
			Box(new Vector3(0f, 0.7f, 0f), new Vector3(3f, 0.9f, 3f), wood: false);
			Stack(-8.4f);
			Box(new Vector3(8.4f, 0.4f, 8.4f), new Vector3(2.8f, 0.8f, 2.8f), wood: false);
			Box(new Vector3(8.4f, 3.15f, 8.4f), new Vector3(2.2f, 0.65f, 2.2f), wood: false);
			Box(new Vector3(-8.4f, 2.1f, 8.4f), new Vector3(2f, 0.5f, 2f), wood: true);
			Box(new Vector3(8.4f, 2.1f, -8.4f), new Vector3(2f, 0.5f, 2f), wood: true);
			Mark(new Vector3(-8.4f, 6.2f, 0f));
			Mark(new Vector3(8.4f, 0.9f, 8.4f));
		}

		private static void BuildFallGrid()
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: 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)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			int num = 5;
			float num2 = 2.2f;
			float num3 = 0.18f;
			float num4 = num2 + num3;
			float num5 = 0f - (float)(num - 1) * 0.5f * num4;
			Vector3 localPos = default(Vector3);
			for (int i = 0; i < num; i++)
			{
				for (int j = 0; j < num; j++)
				{
					((Vector3)(ref localPos))..ctor(num5 + (float)j * num4, 0.35f, num5 + (float)i * num4);
					if ((j == 0 || j == num - 1) && (i == 0 || i == num - 1))
					{
						Box(localPos, new Vector3(num2, 0.7f, num2), wood: false);
					}
					else
					{
						FallBox(localPos, new Vector3(num2, 0.7f, num2), wood: false, 0.55f);
					}
				}
			}
			SafeMark(new Vector3(num5, 0.35f, num5), 0.7f);
			SafeMark(new Vector3(num5, 0.35f, 0f - num5), 0.7f);
			SafeMark(new Vector3(0f - num5, 0.35f, num5), 0.7f);
			SafeMark(new Vector3(0f - num5, 0.35f, 0f - num5), 0.7f);
		}

		private static void BuildFallRing()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			SafePad(new Vector3(-8.6f, 0.5f, -8.6f), new Vector3(3.4f, 1f, 3.4f));
			SafePad(new Vector3(-8.6f, 0.5f, 8.6f), new Vector3(3.4f, 1f, 3.4f));
			SafePad(new Vector3(8.6f, 0.5f, -8.6f), new Vector3(3.4f, 1f, 3.4f));
			SafePad(new Vector3(8.6f, 0.5f, 8.6f), new Vector3(3.4f, 1f, 3.4f));
			int num = 10;
			float num2 = 5.1f;
			for (int i = 0; i < num; i++)
			{
				float num3 = (float)i * (float)Math.PI * 2f / (float)num;
				FallBox(new Vector3(Mathf.Cos(num3) * num2, 0.38f, Mathf.Sin(num3) * num2), new Vector3(2.15f, 0.65f, 2.15f), wood: false, 0.45f + (float)(i % 3) * 0.12f);
			}
		}

		private static void BuildFallLanes()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			SafePad(new Vector3(-9.2f, 0.5f, -3.2f), new Vector3(3.2f, 1f, 3.2f));
			SafePad(new Vector3(-9.2f, 0.5f, 3.2f), new Vector3(3.2f, 1f, 3.2f));
			SafePad(new Vector3(9.2f, 0.5f, -3.2f), new Vector3(3.2f, 1f, 3.2f));
			SafePad(new Vector3(9.2f, 0.5f, 3.2f), new Vector3(3.2f, 1f, 3.2f));
			float[] array = new float[3] { -2.4f, 0f, 2.4f };
			for (int i = 0; i < array.Length; i++)
			{
				for (int j = 0; j < 5; j++)
				{
					FallBox(new Vector3(-5.2f + (float)j * 2.6f, 0.35f, array[i]), new Vector3(2.15f, 0.6f, 1.85f), wood: false, 0.4f + (float)j * 0.08f);
				}
			}
		}

		private static void BuildFallSteps()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: 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_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: 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)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			SafePad(new Vector3(-9f, 0.5f, -3f), new Vector3(3.2f, 1f, 3.2f));
			SafePad(new Vector3(-9f, 0.5f, 3f), new Vector3(3.2f, 1f, 3.2f));
			SafePad(new Vector3(9f, 0.5f, -3f), new Vector3(3.2f, 1f, 3.2f));
			SafePad(new Vector3(9f, 0.5f, 3f), new Vector3(3.2f, 1f, 3.2f));
			Vector3[] array = (Vector3[])(object)new Vector3[9]
			{
				new Vector3(-5.4f, 0.35f, -1.6f),
				new Vector3(-2.6f, 0.7f, 0.4f),
				new Vector3(0f, 1.05f, -0.8f),
				new Vector3(2.6f, 0.7f, 1.4f),
				new Vector3(5.4f, 0.35f, 0.2f),
				new Vector3(-3.8f, 0.35f, 2.6f),
				new Vector3(3.8f, 0.35f, -2.8f),
				new Vector3(0f, 0.35f, 3.2f),
				new Vector3(0f, 0.35f, -3.4f)
			};
			for (int i = 0; i < array.Length; i++)
			{
				float num = 1.7f + (float)(i % 3) * 0.25f;
				FallBox(array[i], new Vector3(num, 0.55f, num), wood: false, 0.38f + (float)(i % 4) * 0.1f);
			}
		}

		private static void BuildSeesaw()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("SeesawAnchor");
			val.transform.SetParent(_root.transform, false);
			val.transform.localPosition = Vector3.zero;
			Rigidbody val2 = val.AddComponent<Rigidbody>();
			val2.isKinematic = true;
			val2.useGravity = false;
			GameObject obj = Box(Vector3.zero, new Vector3(14f, 0.5f, 2.6f), wood: true);
			((Object)obj).name = "Seesaw";
			Rigidbody obj2 = obj.AddComponent<Rigidbody>();
			obj2.mass = 90f;
			obj2.useGravity = false;
			obj2.linearDamping = 1.1f;
			obj2.angularDamping = 3.6f;
			obj2.centerOfMass = new Vector3(0f, -0.2f, 0f);
			obj2.constraints = (RigidbodyConstraints)46;
			ConfigurableJoint obj3 = obj.AddComponent<ConfigurableJoint>();
			((Joint)obj3).connectedBody = val2;
			((Joint)obj3).autoConfigureConnectedAnchor = true;
			obj3.xMotion = (ConfigurableJointMotion)0;
			obj3.yMotion = (ConfigurableJointMotion)0;
			obj3.zMotion = (ConfigurableJointMotion)0;
			obj3.angularYMotion = (ConfigurableJointMotion)0;
			obj3.angularXMotion = (ConfigurableJointMotion)1;
			obj3.angularZMotion = (ConfigurableJointMotion)1;
			SoftJointLimit val3 = default(SoftJointLimit);
			((SoftJointLimit)(ref val3)).limit = 18f;
			SoftJointLimit val4 = val3;
			val3 = default(SoftJointLimit);
			((SoftJointLimit)(ref val3)).limit = -18f;
			obj3.lowAngularXLimit = val3;
			obj3.highAngularXLimit = val4;
			obj3.angularZLimit = val4;
			obj3.rotationDriveMode = (RotationDriveMode)1;
			JointDrive slerpDrive = default(JointDrive);
			((JointDrive)(ref slerpDrive)).positionSpring = 70f;
			((JointDrive)(ref slerpDrive)).positionDamper = 22f;
			((JointDrive)(ref slerpDrive)).maximumForce = 1E+09f;
			obj3.slerpDrive = slerpDrive;
			obj3.targetRotation = Quaternion.identity;
			Box(new Vector3(0f, -0.55f, 0f), new Vector3(1.6f, 0.7f, 1.6f), wood: false);
			Mark(new Vector3(-5.8f, 0.4f, 0f));
			Mark(new Vector3(5.8f, 0.4f, 0f));
		}

		private static void BuildMovers()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			SafePad(new Vector3(-9f, 0.5f, -3.2f), new Vector3(3.3f, 1f, 3.3f));
			SafePad(new Vector3(-9f, 0.5f, 3.2f), new Vector3(3.3f, 1f, 3.3f));
			SafePad(new Vector3(9f, 0.5f, -3.2f), new Vector3(3.3f, 1f, 3.3f));
			SafePad(new Vector3(9f, 0.5f, 3.2f), new Vector3(3.3f, 1f, 3.3f));
			MoveBox(new Vector3(-4f, 0.4f, -3.5f), new Vector3(-4f, 0.4f, 3.5f), new Vector3(2.6f, 0.55f, 2.6f), 4.2f, 0f);
			MoveBox(new Vector3(0f, 0.4f, 3.5f), new Vector3(0f, 0.4f, -3.5f), new Vector3(2.6f, 0.55f, 2.6f), 4.2f, 1.5f);
			MoveBox(new Vector3(4f, 0.4f, -3.5f), new Vector3(4f, 0.4f, 3.5f), new Vector3(2.6f, 0.55f, 2.6f), 4.2f, 3f);
		}

		private static void BuildMoveFerry()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			SafePad(new Vector3(-8.6f, 0.5f, -8.6f), new Vector3(3.4f, 1f, 3.4f));
			SafePad(new Vector3(8.6f, 0.5f, -8.6f), new Vector3(3.4f, 1f, 3.4f));
			SafePad(new Vector3(-8.6f, 0.5f, 8.6f), new Vector3(3.4f, 1f, 3.4f));
			SafePad(new Vector3(8.6f, 0.5f, 8.6f), new Vector3(3.4f, 1f, 3.4f));
			MoveBox(new Vector3(-3.4f, 0.4f, -4.2f), new Vector3(-3.4f, 0.4f, 4.2f), new Vector3(2.5f, 0.55f, 2.5f), 5f, 0f);
			MoveBox(new Vector3(0f, 0.4f, 4.2f), new Vector3(0f, 0.4f, -4.2f), new Vector3(2.5f, 0.55f, 2.5f), 5f, 1.6f);
			MoveBox(new Vector3(3.4f, 0.4f, -4.2f), new Vector3(3.4f, 0.4f, 4.2f), new Vector3(2.5f, 0.55f, 2.5f), 5f, 3.2f);
			MoveBox(new Vector3(-6.2f, 0.9f, 0f), new Vector3(6.2f, 0.9f, 0f), new Vector3(2.2f, 0.5f, 2.2f), 6.2f, 0.8f);
		}

		private static void BuildMoveCircle()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			SafePad(new Vector3(-9.2f, 0.5f, -9.2f), new Vector3(3.3f, 1f, 3.3f));
			SafePad(new Vector3(-9.2f, 0.5f, 9.2f), new Vector3(3.3f, 1f, 3.3f));
			SafePad(new Vector3(9.2f, 0.5f, -9.2f), new Vector3(3.3f, 1f, 3.3f));
			SafePad(new Vector3(9.2f, 0.5f, 9.2f), new Vector3(3.3f, 1f, 3.3f));
			for (int i = 0; i < 5; i++)
			{
				float phase = (float)i * ((float)Math.PI * 2f / 5f);
				OrbitBox(Vector3.zero, 4.4f, new Vector3(2.35f, 0.55f, 2.35f), 7.5f, phase);
			}
		}

		private static void BuildElevators()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			SafePad(new Vector3(-8f, 0.5f, 0f), new Vector3(3.2f, 1f, 3.2f));
			SafePad(new Vector3(8f, 0.5f, 0f), new Vector3(3.2f, 1f, 3.2f));
			MoveBox(new Vector3(-3.5f, 0.4f, 0f), new Vector3(-3.5f, 6.5f, 0f), new Vector3(2.8f, 0.55f, 2.8f), 5.5f, 0f);
			MoveBox(new Vector3(0f, 6.5f, 0f), new Vector3(0f, 0.4f, 0f), new Vector3(2.8f, 0.55f, 2.8f), 5.5f, 0f);
			MoveBox(new Vector3(3.5f, 0.4f, 0f), new Vector3(3.5f, 6.5f, 0f), new Vector3(2.8f, 0.55f, 2.8f), 5.5f, 2.7f);
		}

		private static void BuildDropPath()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			SafePad(new Vector3(-9f, 0.5f, 0f), new Vector3(3.6f, 1f, 3.6f));
			SafePad(new Vector3(9f, 0.5f, 0f), new Vector3(3.6f, 1f, 3.6f));
			for (int i = 0; i < 6; i++)
			{
				FallBox(new Vector3(-5.5f + (float)i * 2.2f, 0.35f, (i % 2 == 0) ? 0.9f : (-0.9f)), new Vector3(1.8f, 0.55f, 1.8f), wood: true, 0.4f);
			}
		}

		private static void BuildDualSpin()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = MakeSpin(new Vector3(-5.5f, 0f, 0f), 20f, Vector3.up);
			BoxOn(val.transform, Vector3.zero, new Vector3(10f, 0.6f, 2.1f), wood: true);
			BoxOn(val.transform, Vector3.zero, new Vector3(2.1f, 0.6f, 10f), wood: true);
			BoxOn(val.transform, Vector3.zero, new Vector3(2.4f, 0.75f, 2.4f), wood: false);
			GameObject obj = MakeSpin(new Vector3(5.5f, 0f, 0f), -20f, Vector3.up);
			BoxOn(obj.transform, Vector3.zero, new Vector3(10f, 0.6f, 2.1f), wood: true);
			BoxOn(obj.transform, Vector3.zero, new Vector3(2.1f, 0.6f, 10f), wood: true);
			BoxOn(obj.transform, Vector3.zero, new Vector3(2.4f, 0.75f, 2.4f), wood: false);
			MarkOn(val.transform, new Vector3(-4f, 0.5f, 0f));
			MarkOn(obj.transform, new Vector3(4f, 0.5f, 0f));
		}

		private static void BuildWindmill()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			SafePad(new Vector3(-8.5f, 0.5f, 0f), new Vector3(3.4f, 1f, 3.4f));
			SafePad(new Vector3(8.5f, 0.5f, 0f), new Vector3(3.4f, 1f, 3.4f));
			GameObject obj = MakeSpin(new Vector3(0f, 4.2f, 0f), 28f, Vector3.forward);
			BoxOn(obj.transform, Vector3.zero, new Vector3(14f, 0.7f, 1.8f), wood: true);
			BoxOn(obj.transform, Vector3.zero, new Vector3(1.8f, 14f, 0.7f), wood: true);
			BoxOn(obj.transform, Vector3.zero, new Vector3(2.2f, 2.2f, 2.2f), wood: false);
		}

		private static void BuildCross()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			Box(new Vector3(0f, 0.4f, 0f), new Vector3(16f, 0.75f, 3.2f), wood: false);
			Box(new Vector3(0f, 0.4f, 0f), new Vector3(3.2f, 0.75f, 16f), wood: false);
			Box(new Vector3(0f, 0.85f, 0f), new Vector3(3.6f, 0.6f, 3.6f), wood: true);
			Box(new Vector3(6.5f, 1.8f, 0f), new Vector3(2f, 0.45f, 2f), wood: true);
			Box(new Vector3(-6.5f, 1.8f, 0f), new Vector3(2f, 0.45f, 2f), wood: true);
			Mark(new Vector3(-7.2f, 0.9f, 0f));
			Mark(new Vector3(7.2f, 0.9f, 0f));
		}

		private static void BuildOceanBridge()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			FindPlankAsset(out var mesh, out var mats);
			float num = 8.5f;
			float num2 = 4.2f;
			float num3 = 0.5f;
			float num4 = 0.62f;
			float num5 = num + num2 * 2f;
			float num6 = (num + num2) * 0.5f;
			LayDockRun(mesh, mats, new Vector3(0f, num4, num6), new Vector3(num5, num3, num2));
			LayDockRun(mesh, mats, new Vector3(0f, num4, 0f - num6), new Vector3(num5, num3, num2));
			LayDockRun(mesh, mats, new Vector3(num6, num4, 0f), new Vector3(num2, num3, num));
			LayDockRun(mesh, mats, new Vector3(0f - num6, num4, 0f), new Vector3(num2, num3, num));
			float num7 = num4 + num3 * 0.5f;
			float num8 = num6;
			Mark(new Vector3(0f - num8, num7, 0f - num8));
			Mark(new Vector3(0f - num8, num7, num8));
			Mark(new Vector3(num8, num7, 0f - num8));
			Mark(new Vector3(num8, num7, num8));
			Debug.Log((object)("[HowToFishPvp] Ocean docks mesh=" + (((Object)(object)mesh != (Object)null) ? ((Object)mesh).name : "wood box") + " hole=" + num));
		}

		private static void LayDockRun(Mesh mesh, Material[] mats, Vector3 center, Vector3 size)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("OceanDock");
			val.layer = _layer;
			try
			{
				val.tag = "Level";
			}
			catch
			{
			}
			val.transform.SetParent(_root.transform, false);
			val.transform.localPosition = center;
			val.transform.localRotation = Quaternion.identity;
			BoxCollider obj2 = val.AddComponent<BoxCollider>();
			obj2.center = Vector3.zero;
			obj2.size = size;
			if ((Object)(object)mesh != (Object)null)
			{
				TilePlanks(val, mesh, mats, size);
			}
			else
			{
				StampCube(val, size, wood: true);
			}
		}

		private static void TilePlanks(GameObject dest, Mesh mesh, Material[] mats, Vector3 size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			Bounds bounds = mesh.bounds;
			Vector3 size2 = ((Bounds)(ref bounds)).size;
			if (size2.x < 0.05f)
			{
				size2.x = 1f;
			}
			if (size2.y < 0.05f)
			{
				size2.y = 1f;
			}
			if (size2.z < 0.05f)
			{
				size2.z = 1f;
			}
			bool flag = size2.x >= size2.z;
			float num = (flag ? size2.x : size2.z);
			float num2 = (flag ? size2.z : size2.x);
			bool flag2 = size.x >= size.z;
			float num3 = (flag2 ? size.x : size.z);
			float num4 = (flag2 ? size.z : size.x);
			int num5 = Mathf.Max(1, Mathf.RoundToInt(num3 / Mathf.Max(0.85f, num)));
			float num6 = num3 / (float)num5;
			float num7 = ((flag == flag2) ? 0f : 90f);
			Vector3 ls = (flag ? new Vector3(num6 / num, size.y / size2.y, num4 / num2) : new Vector3(num4 / num2, size.y / size2.y, num6 / num));
			if (num7 != 0f)
			{
				ls = (flag ? new Vector3(num4 / num2, size.y / size2.y, num6 / num) : new Vector3(num6 / num, size.y / size2.y, num4 / num2));
			}
			for (int i = 0; i < num5; i++)
			{
				float num8 = (0f - num3) * 0.5f + num6 * ((float)i + 0.5f);
				Vector3 lp = (flag2 ? new Vector3(num8, 0f, 0f) : new Vector3(0f, 0f, num8));
				AddMeshPart(dest, mesh, mats, lp, Quaternion.Euler(0f, num7, 0f), ls);
			}
		}

		private static void FindPlankAsset(out Mesh mesh, out Material[] mats)
		{
			mesh = null;
			mats = null;
			int num = 99;
			try
			{
				MeshFilter[] array = Resources.FindObjectsOfTypeAll<MeshFilter>();
				if (array != null)
				{
					foreach (MeshFilter val in array)
					{
						if ((Object)(object)val == (Object)null || (Object)(object)val.sharedMesh == (Object)null || ((Object)(object)_root != (Object)null && ((Component)val).transform.IsChildOf(_root.transform)))
						{
							continue;
						}
						int num2 = PlankRank(((Object)((Component)val).gameObject).name + " " + ((Object)val.sharedMesh).name, val.sharedMesh);
						if (num2 < num)
						{
							num = num2;
							mesh = val.sharedMesh;
							MeshRenderer component = ((Component)val).GetComponent<MeshRenderer>();
							if ((Object)(object)component != (Object)null && ((Renderer)component).sharedMaterials != null && ((Renderer)component).sharedMaterials.Length != 0)
							{
								mats = ((Renderer)component).sharedMaterials;
							}
							if (num2 == 0)
							{
								break;
							}
						}
					}
				}
			}
			catch
			{
			}
			if ((Object)(object)mesh != (Object)null)
			{
				return;
			}
			try
			{
				Mesh[] array2 = Resources.FindObjectsOfTypeAll<Mesh>();
				if (array2 == null)
				{
					return;
				}
				foreach (Mesh val2 in array2)
				{
					if (!((Object)(object)val2 == (Object)null) && UsablePropMesh(val2))
					{
						int num3 = PlankRank(((Object)val2).name, val2);
						if (num3 < num)
						{
							num = num3;
							mesh = val2;
						}
					}
				}
			}
			catch
			{
			}
		}

		private static int PlankRank(string name, Mesh m)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)m == (Object)null)
			{
				return 99;
			}
			string text = name.ToLowerInvariant();
			if (text.IndexOf("curve") >= 0 || text.IndexOf("combined") >= 0 || text.IndexOf("batch") >= 0)
			{
				return 99;
			}
			Bounds bounds = m.bounds;
			Vector3 size = ((Bounds)(ref bounds)).size;
			float num = Mathf.Max(size.x, Mathf.Max(size.y, size.z));
			if (num < 0.35f || num > 22f)
			{
				return 99;
			}
			string text2 = ((Object)m).name.ToLowerInvariant();
			if (text2 == "plank")
			{
				return 0;
			}
			if (text2.IndexOf("plank") >= 0)
			{
				return 1;
			}
			if (text2.IndexOf("docks") >= 0 || text.IndexOf("docks") >= 0)
			{
				return 2;
			}
			if (text2.IndexOf("dock") >= 0 || text.IndexOf("pier") >= 0 || text.IndexOf("walkway") >= 0 || text.IndexOf("boardwalk") >= 0 || text.IndexOf("jetty") >= 0)
			{
				return 3;
			}
			return 99;
		}

		private static GameObject MakeSpin(Vector3 localPos, float deg, Vector3 axis)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			GameObject val = new GameObject("Spinner")
			{
				layer = _layer
			};
			val.transform.SetParent(_root.transform, false);
			val.transform.localPosition = localPos;
			Rigidbody obj = val.AddComponent<Rigidbody>();
			obj.isKinematic = true;
			obj.useGravity = false;
			obj.interpolation = (RigidbodyInterpolation)1;
			PvpSpin pvpSpin = val.AddComponent<PvpSpin>();
			pvpSpin.DegPerSec = deg;
			pvpSpin.Axis = axis;
			return val;
		}

		private static GameObject FallBox(Vector3 localPos, Vector3 size, bool wood, float delay)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Box(localPos, size, wood);
			Rigidbody obj2 = obj.AddComponent<Rigidbody>();
			obj2.isKinematic = true;
			obj2.useGravity = false;
			obj2.mass = 50f;
			obj2.collisionDetectionMode = (CollisionDetectionMode)1;
			obj.AddComponent<PvpFallPad>().Delay = delay;
			return obj;
		}

		private static GameObject MoveBox(Vector3 a, Vector3 b, Vector3 size, float period, float phase)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = Box(a, size, wood: false);
			Rigidbody obj2 = obj.AddComponent<Rigidbody>();
			obj2.isKinematic = true;
			obj2.useGravity = false;
			obj2.interpolation = (RigidbodyInterpolation)1;
			PvpMovePad pvpMovePad = obj.AddComponent<PvpMovePad>();
			pvpMovePad.LocalA = a;
			pvpMovePad.LocalB = b;
			pvpMovePad.Period = period;
			pvpMovePad.Phase = phase;
			return obj;
		}

		private static GameObject OrbitBox(Vector3 center, float radius, Vector3 size, float period, float phase)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = center + new Vector3(Mathf.Cos(phase) * radius, 0f, Mathf.Sin(phase) * radius);
			GameObject obj = Box(val, size, wood: false);
			Rigidbody obj2 = obj.AddComponent<Rigidbody>();
			obj2.isKinematic = true;
			obj2.useGravity = false;
			obj2.interpolation = (RigidbodyInterpolation)1;
			PvpMovePad pvpMovePad = obj.AddComponent<PvpMovePad>();
			pvpMovePad.LocalA = center;
			pvpMovePad.LocalB = val;
			pvpMovePad.Radius = radius;
			pvpMovePad.Period = period;
			pvpMovePad.Phase = phase;
			return obj;
		}

		private static void SafePad(Vector3 localPos, Vector3 size)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			Box(localPos, size, wood: false);
			SafeMark(localPos, size.y);
		}

		private static void SafeMark(Vector3 padCenter, float padHeight)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			Mark(new Vector3(padCenter.x, padCenter.y + padHeight * 0.5f + 0.08f, padCenter.z));
		}

		private static GameObject Box(Vector3 localPos, Vector3 size, bool wood)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return BoxOn(_root.transform, localPos, size, wood);
		}

		private static GameObject BoxOn(Transform parent, Vector3 localPos, Vector3 size, bool wood)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Pad");
			val.layer = _layer;
			try
			{
				val.tag = "Level";
			}
			catch
			{
			}
			val.transform.SetParent(parent, false);
			val.transform.localPosition = localPos;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			BoxCollider obj2 = val.AddComponent<BoxCollider>();
			obj2.size = size;
			obj2.center = Vector3.zero;
			StampForm(val, size, wood);
			return val;
		}

		private static void StampForm(GameObject dest, Vector3 size, bool wood)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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)
			GameObject val = new GameObject("Rock")
			{
				layer = dest.layer
			};
			val.transform.SetParent(dest.transform, false);
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			val.AddComponent<MeshFilter>().sharedMesh = MakeForm(size, _propI++);
			MeshRenderer obj = val.AddComponent<MeshRenderer>();
			((Renderer)obj).enabled = true;
			((Renderer)obj).lightmapIndex = -1;
			((Renderer)obj).sharedMaterial = SurfMat(wood: false, size);
		}

		private static Mesh MakeForm(Vector3 size, int seed)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Expected O, but got Unknown
			Random random = new Random(seed * 7919 + 13);
			bool flag = size.y > Mathf.Max(size.x, size.z) * 1.15f;
			int num = 5 + random.Next(0, 2);
			float num2 = size.x * 0.5f;
			float num3 = size.y * 0.5f;
			float num4 = size.z * 0.5f;
			Vector3[] array = (Vector3[])(object)new Vector3[num];
			Vector3[] array2 = (Vector3[])(object)new Vector3[num];
			for (int i = 0; i < num; i++)
			{
				float num5 = (float)i / (float)num * (float)Math.PI * 2f + ((float)random.NextDouble() - 0.5f) * 0.4f;
				float num6 = 0.72f + (float)random.NextDouble() * 0.36f;
				float num7 = 0.42f + (float)random.NextDouble() * 0.28f;
				if (flag)
				{
					num7 *= 0.7f;
				}
				array[i] = new Vector3(Mathf.Cos(num5) * num2 * num6, num3, Mathf.Sin(num5) * num4 * num6);
				array2[i] = new Vector3(Mathf.Cos(num5) * num2 * num7, 0f - num3, Mathf.Sin(num5) * num4 * num7);
			}
			Vector3 a = default(Vector3);
			((Vector3)(ref a))..ctor(0f, num3, 0f);
			Vector3 a2 = default(Vector3);
			((Vector3)(ref a2))..ctor(0f, 0f - num3, 0f);
			List<Vector3> list = new List<Vector3>(num * 12);
			List<Vector3> list2 = new List<Vector3>(num * 12);
			List<Vector2> list3 = new List<Vector2>(num * 12);
			List<int> list4 = new List<int>(num * 12);
			for (int j = 0; j < num; j++)
			{
				int num8 = (j + 1) % num;
				AddTri(list, list2, list3, list4, a, array[num8], array[j], size);
				AddTri(list, list2, list3, list4, a2, array2[j], array2[num8], size);
				AddTri(list, list2, list3, list4, array[j], array[num8], array2[num8], size);
				AddTri(list, list2, list3, list4, array[j], array2[num8], array2[j], size);
			}
			Mesh val = new Mesh
			{
				name = "PvpRock"
			};
			val.SetVertices(list);
			val.SetTriangles(list4, 0);
			val.SetUVs(0, list3);
			val.SetNormals(list2);
			val.RecalculateBounds();
			return val;
		}

		private static void AddTri(List<Vector3> verts, List<Vector3> norms, List<Vector2> uvs, List<int> tris, Vector3 a, Vector3 b, Vector3 c, Vector3 size)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 item = Vector3.Cross(b - a, c - a);
			if (((Vector3)(ref item)).sqrMagnitude < 1E-06f)
			{
				item = Vector3.up;
			}
			else
			{
				((Vector3)(ref item)).Normalize();
			}
			int count = verts.Count;
			verts.Add(a);
			verts.Add(b);
			verts.Add(c);
			norms.Add(item);
			norms.Add(item);
			norms.Add(item);
			uvs.Add(FormUv(a, size));
			uvs.Add(FormUv(b, size));
			uvs.Add(FormUv(c, size));
			tris.Add(count);
			tris.Add(count + 1);
			tris.Add(count + 2);
		}

		private static Vector2 FormUv(Vector3 p, Vector3 size)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(p.x / Mathf.Max(0.01f, size.x) + 0.5f, p.z / Mathf.Max(0.01f, size.z) + 0.5f);
		}

		private static bool TryPickProp(bool wood, out PropKit prop)
		{
			List<PropKit> list = ((wood && _woodProps.Count > 0) ? _woodProps : _rockProps);
			if (list.Count == 0)
			{
				list = ((_rockProps.Count > 0) ? _rockProps : _woodProps);
			}
			if (list.Count == 0)
			{
				prop = default(PropKit);
				return false;
			}
			prop = list[_propI % list.Count];
			_propI++;
			if (!((Object)(object)prop.Mesh != (Object)null))
			{
				return (Object)(object)prop.Src != (Object)null;
			}
			return true;
		}

		private static void StampProp(GameObject dest, PropKit prop, Vector3 size)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Visual");
			val.layer = dest.layer;
			val.transform.SetParent(dest.transform, false);
			int num = 0;
			if ((Object)(object)prop.Src != (Object)null)
			{
				num = CopySourceMeshes(prop.Src, val);
			}
			if (num == 0 && (Object)(object)prop.Mesh != (Object)null)
			{
				AddMeshPart(val, prop.Mesh, prop.Mats, Vector3.zero, Quaternion.identity, Vector3.one);
				num = 1;
			}
			if (num == 0)
			{
				Object.Destroy((Object)(object)val);
				StampCube(dest, size, prop.Wood);
				return;
			}
			Bounds val2 = LocalBounds(val);
			Vector3 size2 = ((Bounds)(ref val2)).size;
			if (size2.x < 0.05f)
			{
				size2.x = 1f;
			}
			if (size2.y < 0.05f)
			{
				size2.y = 1f;
			}
			if (size2.z < 0.05f)
			{
				size2.z = 1f;
			}
			Vector3 val3 = default(Vector3);
			if (prop.Wood)
			{
				((Vector3)(ref val3))..ctor(size.x / size2.x, size.y / size2.y, size.z / size2.z);
			}
			else
			{
				float num2 = Mathf.Max(size.x / size2.x, size.z / size2.z);
				((Vector3)(ref val3))..ctor(num2, Mathf.Max(num2 * 0.35f, size.y / size2.y), num2);
			}
			val.transform.localScale = val3;
			val.transform.localPosition = new Vector3((0f - ((Bounds)(ref val2)).center.x) * val3.x, (0f - ((Bounds)(ref val2)).center.y) * val3.y, (0f - ((Bounds)(ref val2)).center.z) * val3.z);
		}

		private static int CopySourceMeshes(GameObject src, GameObject dest)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			MeshFilter[] componentsInChildren = src.GetComponentsInChildren<MeshFilter>(true);
			if (componentsInChildren == null)
			{
				return 0;
			}
			foreach (MeshFilter val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && UsablePropMesh(val.sharedMesh))
				{
					Material[] mats = null;
					MeshRenderer component = ((Component)val).GetComponent<MeshRenderer>();
					if ((Object)(object)component != (Object)null)
					{
						mats = ((Renderer)component).sharedMaterials;
					}
					Vector3 lp = src.transform.InverseTransformPoint(((Component)val).transform.position);
					Quaternion lr = Quaternion.Inverse(src.transform.rotation) * ((Component)val).transform.rotation;
					Vector3 ls = DivScale(((Component)val).transform.lossyScale, src.transform.lossyScale);
					AddMeshPart(dest, val.sharedMesh, mats, lp, lr, ls);
					num++;
				}
			}
			return num;
		}

		private static Vector3 DivScale(Vector3 a, Vector3 b)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3((b.x != 0f) ? (a.x / b.x) : 1f, (b.y != 0f) ? (a.y / b.y) : 1f, (b.z != 0f) ? (a.z / b.z) : 1f);
		}

		private static void AddMeshPart(GameObject dest, Mesh mesh, Material[] mats, Vector3 lp, Quaternion lr, Vector3 ls)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Mesh")
			{
				layer = dest.layer
			};
			val.transform.SetParent(dest.transform, false);
			val.transform.localPosition = lp;
			val.transform.localRotation = lr;
			val.transform.localScale = ls;
			val.AddComponent<MeshFilter>().sharedMesh = mesh;
			MeshRenderer val2 = val.AddComponent<MeshRenderer>();
			((Renderer)val2).enabled = true;
			((Renderer)val2).lightmapIndex = -1;
			if (mats != null && mats.Length != 0)
			{
				((Renderer)val2).sharedMaterials = mats;
			}
			else
			{
				((Renderer)val2).sharedMaterial = SurfMat(wood: false, Vector3.one);
			}
		}

		private static Bounds LocalBounds(GameObject go)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			MeshFilter[] componentsInChildren = go.GetComponentsInChildren<MeshFilter>(true);
			Bounds result = default(Bounds);
			((Bounds)(ref result))..ctor(Vector3.zero, Vector3.zero);
			bool flag = false;
			Bounds val3 = default(Bounds);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (!((Object)(object)componentsInChildren[i] == (Object)null) && !((Object)(object)componentsInChildren[i].sharedMesh == (Object)null))
				{
					Bounds bounds = componentsInChildren[i].sharedMesh.bounds;
					Vector3 val = ((Component)componentsInChildren[i]).transform.localPosition + Vector3.Scale(((Bounds)(ref bounds)).center, ((Component)componentsInChildren[i]).transform.localScale);
					Vector3 val2 = Vector3.Scale(((Bounds)(ref bounds)).size, AbsVec(((Component)componentsInChildren[i]).transform.localScale));
					((Bounds)(ref val3))..ctor(val, val2);
					if (!flag)
					{
						result = val3;
						flag = true;
					}
					else
					{
						((Bounds)(ref result)).Encapsulate(val3);
					}
				}
			}
			if (!flag)
			{
				return new Bounds(Vector3.zero, Vector3.one);
			}
			return result;
		}

		private static Vector3 AbsVec(Vector3 v)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(Mathf.Abs(v.x), Mathf.Abs(v.y), Mathf.Abs(v.z));
		}

		private static void StampCube(GameObject dest, Vector3 size, bool wood)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)obj).name = "Cube";
			obj.layer = dest.layer;
			Object.Destroy((Object)(object)obj.GetComponent<Collider>());
			obj.transform.SetParent(dest.transform, false);
			obj.transform.localPosition = Vector3.zero;
			obj.transform.localScale = size;
			MeshRenderer component = obj.GetComponent<MeshRenderer>();
			((Renderer)component).enabled = true;
			((Renderer)component).lightmapIndex = -1;
			((Renderer)component).sharedMaterial = SurfMat(wood, size);
		}

		private static void Mark(Vector3 localPos)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			MarkOn(_root.transform, localPos);
		}

		private static void MarkOn(Transform parent, Vector3 localPos)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = new GameObject("Spawn").transform;
			transform.SetParent(parent, false);
			transform.localPosition = localPos + Vector3.up * 1.05f;
			_spawns.Add(transform);
		}

		private static void HarvestMats()
		{
			_stoneTex.Clear();
			_woodTex.Clear();
			_surfI = 0;
			HashSet<int> seen = new HashSet<int>();
			CollectFromRenderers(Object.FindObjectsOfType<Renderer>(), seen);
			if (_stoneTex.Count == 0 || _woodTex.Count == 0)
			{
				try
				{
					CollectNamedTextures(seen);
				}
				catch
				{
				}
			}
			Debug.Log((object)("[HowToFishPvp] Harvested stoneTex=" + _stoneTex.Count + " woodTex=" + _woodTex.Count));
		}

		private static void HarvestProps()
		{
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			_woodProps.Clear();
			_rockProps.Clear();
			_propI = 0;
			HashSet<int> hashSet = new HashSet<int>();
			MeshFilter[] array = Object.FindObjectsOfType<MeshFilter>();
			Bounds bounds;
			if (array != null)
			{
				foreach (MeshFilter val in array)
				{
					if ((Object)(object)val == (Object)null || (Object)(object)val.sharedMesh == (Object)null || ((Object)(object)_root != (Object)null && ((Component)val).transform.IsChildOf(_root.transform)) || (Object)(object)((Component)val).GetComponentInParent<Player>() != (Object)null || (Object)(object)((Component)val).GetComponentInParent<Item>() != (Object)null || !UsablePropMesh(val.sharedMesh))
					{
						continue;
					}
					int instanceID = ((Object)val.sharedMesh).GetInstanceID();
					if (hashSet.Contains(instanceID))
					{
						continue;
					}
					string n = (((Object)((Component)val).gameObject).name + " " + ((Object)val.sharedMesh).name).ToLowerInvariant();
					if (SkipName(n) || IsLutName(n) || !IsPropName(n))
					{
						continue;
					}
					bounds = val.sharedMesh.bounds;
					Vector3 size = ((Bounds)(ref bounds)).size;
					float num = Mathf.Max(size.x, Mathf.Max(size.y, size.z));
					if (!(num < 0.25f) && !(num > 18f))
					{
						hashSet.Add(instanceID);
						PropKit item = new PropKit
						{
							Src = ((Component)val).gameObject,
							Mesh = val.sharedMesh,
							Mats = (((Object)(object)((Component)val).GetComponent<MeshRenderer>() != (Object)null) ? ((Renderer)((Component)val).GetComponent<MeshRenderer>()).sharedMaterials : null),
							Wood = IsWoodName(n)
						};
						if (item.Wood)
						{
							_woodProps.Add(item);
						}
						else
						{
							_rockProps.Add(item);
						}
					}
				}
			}
			if (_rockProps.Count == 0 && _woodProps.Count == 0)
			{
				try
				{
					Mesh[] array2 = Resources.FindObjectsOfTypeAll<Mesh>();
					if (array2 != null)
					{
						foreach (Mesh val2 in array2)
						{
							if (!UsablePropMesh(val2))
							{
								continue;
							}
							string n2 = ((Object)val2).name.ToLowerInvariant();
							if (!IsPropName(n2))
							{
								continue;
							}
							bounds = val2.bounds;
							Vector3 size2 = ((Bounds)(ref bounds)).size;
							float num2 = Mathf.Max(size2.x, Mathf.Max(size2.y, size2.z));
							if (num2 < 0.25f || num2 > 18f)
							{
								continue;
							}
							int instanceID2 = ((Object)val2).GetInstanceID();
							if (!hashSet.Contains(instanceID2))
							{
								hashSet.Add(instanceID2);
								PropKit item2 = new PropKit
								{
									Mesh = val2,
									Wood = IsWoodName(n2)
								};
								if (item2.Wood)
								{
									_woodProps.Add(item2);
								}
								else
								{
									_rockProps.Add(item2);
								}
							}
						}
					}
				}
				catch
				{
				}
			}
			Debug.Log((object)("[HowToFishPvp] Harvested props rock=" + _rockProps.Count + " wood=" + _woodProps.Count));
		}

		private static bool UsablePropMesh(Mesh m)
		{
			if ((Object)(object)m == (Object)null)
			{
				return false;
			}
			string name = ((Object)m).name;
			if (name.IndexOf("Combined", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return false;
			}
			if (name.IndexOf("batch", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return false;
			}
			if (m.vertexCount < 12 || m.vertexCount > 40000)
			{
				return false;
			}
			return true;
		}

		private static bool IsPropName(string n)
		{
			if (IsWoodName(n) || IsStoneName(n))
			{
				return true;
			}
			if (n.IndexOf("crate") < 0 && n.IndexOf("barrel") < 0 && n.IndexOf("chest") < 0 && n.IndexOf("table") < 0 && n.IndexOf("chair") < 0 && n.IndexOf("stool") < 0 && n.IndexOf("fence") < 0 && n.IndexOf("dock") < 0 && n.IndexOf("pier") < 0 && n.IndexOf("plank") < 0 && n.IndexOf("bridge") < 0 && n.IndexOf("pillar") < 0 && n.IndexOf("column") < 0 && n.IndexOf("pot") < 0 && n.IndexOf("bucket") < 0 && n.IndexOf("pallet") < 0 && n.IndexOf("box") < 0 && n.IndexOf("sign") < 0 && n.IndexOf("cabin") < 0 && n.IndexOf("hut") < 0 && n.IndexOf("boulder") < 0 && n.IndexOf("log") < 0 && n.IndexOf("plank") < 0 && n.IndexOf("bench") < 0 && n.IndexOf("wall") < 0)
			{
				return n.IndexOf("brick") >= 0;
			}
			return true;
		}

		private static void CollectFromRenderers(Renderer[] rends, HashSet<int> seen)
		{
			if (rends == null)
			{
				return;
			}
			foreach (Renderer val in rends)
			{
				if ((Object)(object)val == (Object)null || val.sharedMaterials == null || ((Object)(object)_root != (Object)null && ((Component)val).transform.IsChildOf(_root.transform)) || (Object)(object)((Component)val).GetComponentInParent<Player>() != (Object)null || (Object)(object)((Component)val).GetComponentInParent<Item>() != (Object)null)
				{
					continue;
				}
				string text = ((Object)((Component)val).gameObject).name.ToLowerInvariant();
				if (!SkipName(text))
				{
					Material[] sharedMaterials = val.sharedMaterials;
					for (int j = 0; j < sharedMaterials.Length; j++)
					{
						ConsiderMat(sharedMaterials[j], text, seen);
					}
				}
			}
		}

		private static void CollectNamedTextures(HashSet<int> seen)
		{
			Texture2D[] array = Resources.FindObjectsOfTypeAll<Texture2D>();
			if (array == null)
			{
				return;
			}
			foreach (Texture2D val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string n = ((Object)val).name.ToLowerInvariant();
				if (SkipName(n) || IsLutName(n) || !UsableAlbedo((Texture)(object)val))
				{
					continue;
				}
				int instanceID = ((Object)val).GetInstanceID();
				if (!seen.Contains(instanceID))
				{
					if (IsWoodName(n))
					{
						seen.Add(instanceID);
						_woodTex.Add((Texture)(object)val);
					}
					else if (IsStoneName(n))
					{
						seen.Add(instanceID);
						_stoneTex.Add((Texture)(object)val);
					}
				}
			}
		}

		private static void ConsiderMat(Material src, string obj, HashSet<int> seen)
		{
			if ((Object)(object)src == (Object)null)
			{
				return;
			}
			string text = (((Object)src).name + " " + obj + " " + (((Object)(object)src.shader != (Object)null) ? ((Object)src.shader).name : "")).ToLowerInvariant();
			if (SkipName(text) || IsLutName(text))
			{
				return;
			}
			Texture val = AlbedoOf(src);
			if ((Object)(object)val == (Object)null || !UsableAlbedo(val) || IsLutName(((Object)val).name.ToLowerInvariant()))
			{
				return;
			}
			int instanceID = ((Object)val).GetInstanceID();
			if (!seen.Contains(instanceID))
			{
				string n = (text + " " + ((Object)val).name).ToLowerInvariant();
				if (IsWoodName(n))
				{
					seen.Add(instanceID);
					_woodTex.Add(val);
				}
				else if (IsStoneName(n) || IsGroundName(n))
				{
					seen.Add(instanceID);
					_stoneTex.Add(val);
				}
			}
		}

		private static Texture AlbedoOf(Material src)
		{
			string[] array = new string[7] { "_BaseMap", "_MainTex", "_Albedo", "_Diffuse", "_BaseColorMap", "_ColorMap", "_SurfaceAlbedo" };
			for (int i = 0; i < array.Length; i++)
			{
				try
				{
					if (src.HasProperty(array[i]))
					{
						Texture texture = src.GetTexture(array[i]);
						if ((Object)(object)texture != (Object)null)
						{
							return texture;
						}
					}
				}
				catch
				{
				}
			}
			try
			{
				return src.mainTexture;
			}
			catch
			{
				return null;
			}
		}

		private static bool UsableAlbedo(Texture tex)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			if ((Object)(object)tex == (Object)null)
			{
				return false;
			}
			if (tex is Cubemap || tex is RenderTexture)
			{
				return false;
			}
			if ((int)tex.dimension != 2)
			{
				return false;
			}
			int width = tex.width;
			int height = tex.height;
			if (width < 64 || height < 64)
			{
				return false;
			}
			if (height <= 32 && width >= 128)
			{
				return false;
			}
			if (width <= 32 && height >= 128)
			{
				return false;
			}
			return true;
		}

		private static bool SkipName(string n)
		{
			if (n.IndexOf("water") < 0 && n.IndexOf("ocean") < 0 && n.IndexOf("sky") < 0 && n.IndexOf("cloud") < 0 && n.IndexOf("particle") < 0 && n.IndexOf("font") < 0 && n.IndexOf("sprite") < 0 && n.IndexOf("gui") < 0 && n.IndexOf("lava") < 0 && n.IndexOf("leaf") < 0 && n.IndexOf("foliage") < 0 && n.IndexOf("grass") < 0 && n.IndexOf("howtofish") < 0 && n.IndexOf("hidden/") < 0 && n.IndexOf("post") < 0 && n.IndexOf("volume") < 0)
			{
				return n.IndexOf("ui_") >= 0;
			}
			return true;
		}

		private static bool IsLutName(string n)
		{
			if (n.IndexOf("lut") < 0 && n.IndexOf("lookup") < 0 && n.IndexOf("ramp") < 0 && n.IndexOf("gradient") < 0 && n.IndexOf("palette") < 0 && n.IndexOf("grading") < 0 && n.IndexOf("colorgrade") < 0 && n.IndexOf("color_grade") < 0 && n.IndexOf("debug") < 0 && n.IndexOf("uvcheck") < 0 && n.IndexOf("checker") < 0 && n.IndexOf("matcap") < 0 && n.IndexOf("toon") < 0 && n.IndexOf("skin") < 0)
			{
				return n.IndexOf("noise") >= 0;
			}
			return true;
		}

		private static bool IsWoodName(string n)
		{
			if (n.IndexOf("wood") < 0 && n.IndexOf("plank") < 0 && n.IndexOf("bench") < 0 && n.IndexOf("bark") < 0 && n.IndexOf("log") < 0 && n.IndexOf("timber") < 0 && n.IndexOf("crate") < 0 && n.IndexOf("board") < 0)
			{
				return n.IndexOf("tree") >= 0;
			}
			return true;
		}

		private static bool IsStoneName(string n)
		{
			if (n.IndexOf("stone") < 0 && n.IndexOf("rock") < 0 && n.IndexOf("cliff") < 0 && n.IndexOf("brick") < 0 && n.IndexOf("cobble") < 0 && n.IndexOf("gravel") < 0 && n.IndexOf("sand") < 0 && n.IndexOf("dirt") < 0 && n.IndexOf("ash") < 0 && n.IndexOf("basalt") < 0 && n.IndexOf("pebble") < 0 && n.IndexOf("concrete") < 0 && n.IndexOf("boulder") < 0)
			{
				return n.IndexOf("slate") >= 0;
			}
			return true;
		}

		private static bool IsGroundName(string n)
		{
			if (n.IndexOf("ground") < 0 && n.IndexOf("path") < 0 && n.IndexOf("soil") < 0 && n.IndexOf("earth") < 0 && n.IndexOf("mud") < 0 && n.IndexOf("island") < 0 && n.IndexOf("cliff") < 0)
			{
				return n.IndexOf("combined") >= 0;
			}
			return true;
		}

		private static Material SurfMat(bool wood, Vector3 size)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			List<Texture> list = ((wood && _woodTex.Count > 0) ? _woodTex : _stoneTex);
			if (list.Count == 0)
			{
				list = ((_stoneTex.Count > 0) ? _stoneTex : _woodTex);
			}
			Texture tex = null;
			if (list.Count > 0)
			{
				tex = list[_surfI % list.Count];
				_surfI++;
			}
			return MakeLit(tex, wood, size);
		}

		private static Material MakeLit(Texture tex, bool wood, Vector3 size)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			int key = (int)((uint)(((Object)(object)tex != (Object)null) ? ((Object)tex).GetInstanceID() : 0) ^ (wood ? 1u : 0u) ^ (uint)((int)(size.x * 10f) << 8)) ^ ((int)(size.z * 10f) << 16);
			if (_clones.TryGetValue(key, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if ((Object)(object)_lit == (Object)null)
			{
				_lit = Shader.Find("Universal Render Pipeline/Lit");
				if ((Object)(object)_lit == (Object)null)
				{
					_lit = Shader.Find("HDRP/Lit");
				}
				if ((Object)(object)_lit == (Object)null)
				{
					_lit = Shader.Find("Standard");
				}
				if ((Object)(object)_lit == (Object)null)
				{
					_lit = Shader.Find("Diffuse");
				}
			}
			value = new Material(_lit);
			Color white = default(Color);
			((Color)(ref white))..ctor(0.58f, 0.55f, 0.5f);
			if ((Object)(object)tex != (Object)null)
			{
				value.mainTexture = tex;
				if (value.HasProperty("_BaseMap"))
				{
					value.SetTexture("_BaseMap", tex);
				}
				if (value.HasProperty("_MainTex"))
				{
					value.SetTexture("_MainTex", tex);
				}
				white = Color.white;
			}
			value.color = white;
			if (value.HasProperty("_BaseColor"))
			{
				value.SetColor("_BaseColor", white);
			}
			if (value.HasProperty("_Color"))
			{
				value.SetColor("_Color", white);
			}
			if (value.HasProperty("_Metallic"))
			{
				value.SetFloat("_Metallic", 0f);
			}
			if (value.HasProperty("_Smoothness"))
			{
				value.SetFloat("_Smoothness", 0.04f);
			}
			if (value.HasProperty("_Glossiness"))
			{
				value.SetFloat("_Glossiness", 0.04f);
			}
			float num = Mathf.Clamp(size.x * 0.45f, 1.2f, 8f);
			float num2 = Mathf.Clamp(size.z * 0.45f, 1.2f, 8f);
			if (value.HasProperty("_BaseMap"))
			{
				value.SetTextureScale("_BaseMap", new Vector2(num, num2));
			}
			if (value.HasProperty("_MainTex"))
			{
				value.SetTextureScale("_MainTex", new Vector2(num, num2));
			}
			_clones[key] = value;
			return value;
		}

		private static string PlanLine()
		{
			if (_plan == null)
			{
				return "";
			}
			string text = "";
			for (int i = 0; i < _plan.Length; i++)
			{
				if (i > 0)
				{
					text += ",";
				}
				text += _plan[i];
			}
			return text;
		}

		private static void Shuffle(List<ArenaMap> list, Random rng)
		{
			for (int num = list.Count - 1; num > 0; num--)
			{
				int index = rng.Next(num + 1);
				ArenaMap value = list[num];
				list[num] = list[index];
				list[index] = value;
			}
		}

		private static void HideIsland()
		{
			RestoreIsland();
			Transform waterXf = MainWater();
			Renderer[] array = Object.FindObjectsOfType<Renderer>();
			if (array != null)
			{
				foreach (Renderer val in array)
				{
					if (!((Object)(object)val == (Object)null) && val.enabled && !KeepVisible(((Component)val).transform, waterXf))
					{
						val.enabled = false;
						_hiddenRends.Add(val);
					}
				}
			}
			Collider[] array2 = Object.FindObjectsOfType<Collider>();
			if (array2 == null)
			{
				return;
			}
			foreach (Collider val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null) && val2.enabled && !val2.isTrigger && !KeepVisible(((Component)val2).transform, waterXf))
				{
					val2.enabled = false;
					_hiddenCols.Add(val2);
				}
			}
		}

		private static bool KeepVisible(Transform t, Transform waterXf)
		{
			if ((Object)(object)t == (Object)null)
			{
				return true;
			}
			if ((Object)(object)_root != (Object)null && ((Object)(object)t == (Object)(object)_root.transform || t.IsChildOf(_root.transform)))
			{
				return true;
			}
			if ((Object)(object)((Component)t).GetComponentInParent<Player>() != (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)t).GetComponentInParent<Item>() != (Object)null)
			{
				return true;
			}
			string text = ((Object)((Component)t).gameObject).name.ToLowerInvariant();
			if (text.IndexOf("howtofish") >= 0)
			{
				return true;
			}
			if ((Object)(object)waterXf != (Object)null && ((Object)(object)t == (Object)(object)waterXf || t.IsChildOf(waterXf)))
			{
				return true;
			}
			if (text.IndexOf("water") >= 0 || text.IndexOf("ocean") >= 0 || text.IndexOf("sea") >= 0)
			{
				return true;
			}
			if (text.IndexOf("wave") >= 0 || text.IndexOf("foam") >= 0 || text.IndexOf("horizon") >= 0)
			{
				return true;
			}
			if (text.IndexOf("sky") >= 0 || text.IndexOf("cloud") >= 0 || text.IndexOf("sun") >= 0)
			{
				return true;
			}
			return false;
		}

		private static void RestoreIsland()
		{
			for (int i = 0; i < _hiddenRends.Count; i++)
			{
				if ((Object)(object)_hiddenRends[i] != (Object)null)
				{
					_hiddenRends[i].enabled = true;
				}
			}
			_hiddenRends.Clear();
			for (int j = 0; j < _hiddenCols.Count; j++)
			{
				if ((Object)(object)_hiddenCols[j] != (Object)null)
				{
					_hiddenCols[j].enabled = true;
				}
			}
			_hiddenCols.Clear();
		}

		private static Transform MainWater()
		{
			try
			{
				object value = AccessTools.Field(typeof(WaterManager), "_instance").GetValue(null);
				if (value != null)
				{
					object? value2 = AccessTools.Field(typeof(WaterManager), "_mainWater").GetValue(value);
					return (Transform)((value2 is Transform) ? value2 : null);
				}
			}
			catch
			{
			}
			return null;
		}

		private static Vector3 FindOpenWater(Vector3 island, float water)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			try
			{
				num = LayerMask.op_Implicit(GameInfo.LevelLayer);
			}
			catch
			{
			}
			try
			{
				num |= LayerMask.op_Implicit(GameInfo.CanJumpOnLayers);
			}
			catch
			{
			}
			if (num == 0)
			{
				num = -5;
			}
			Vector3[] obj3 = new Vector3[6]
			{
				Vector3.forward,
				Vector3.back,
				Vector3.right,
				Vector3.left,
				default(Vector3),
				default(Vector3)
			};
			Vector3 val = Vector3.forward + Vector3.right;
			obj3[4] = ((Vector3)(ref val)).normalized;
			val = Vector3.back + Vector3.left;
			obj3[5] = ((Vector3)(ref val)).normalized;
			Vector3[] array = (Vector3[])(object)obj3;
			float[] array2 = new float[3] { 80f, 120f, 160f };
			RaycastHit val3 = default(RaycastHit);
			for (int i = 0; i < array2.Length; i++)
			{
				for (int j = 0; j < array.Length; j++)
				{
					Vector3 val2 = island + array[j] * array2[i];
					if (!Physics.Raycast(val2 + Vector3.up * 80f, Vector3.down, ref val3, 130f, num, (QueryTriggerInteraction)1))
					{
						return val2;
					}
					if (((RaycastHit)(ref val3)).point.y <= water + 1.8f)
					{
						return val2;
					}
				}
			}
			return island + Vector3.right * 130f;
		}

		private static void MoveToIslandScene(GameObject go)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)Island.CurIsland != (Object)null)
				{
					SceneManager.MoveGameObjectToScene(go, ((Component)Island.CurIsland).gameObject.scene);
				}
			}
			catch
			{
			}
		}

		private static int FirstJumpLayer()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			try
			{
				num = LayerMask.op_Implicit(GameInfo.CanJumpOnLayers);
			}
			catch
			{
			}
			for (int i = 0; i < 32; i++)
			{
				if ((num & (1 << i)) != 0)
				{
					return i;
				}
			}
			return 0;
		}

		private static bool TryIslandSpawn(out Vector3 pos, out float yaw)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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)
			pos = Vector3.zero;
			yaw = 0f;
			try
			{
				SpawnManager[] array = Object.FindObjectsOfType<SpawnManager>();
				if (array == null)
				{
					return false;
				}
				foreach (SpawnManager val in array)
				{
					if ((Object)(object)val == (Object)null || !((Behaviour)val).isActiveAndEnabled)
					{
						continue;
					}
					object? value = AccessTools.Field(typeof(SpawnManager), "_playerSpawnPoint").GetValue(val);
					Transform val2 = (Transform)((value is Transform) ? value : null);
					if (!((Object)(object)val2 == (Object)null))
					{
						pos = val2.position;
						yaw = val2.eulerAngles.y;
						if (((Vector3)(ref pos)).sqrMagnitude > 0.01f)
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}
	}
	internal sealed class PvpSpin : MonoBehaviour
	{
		public float DegPerSec = 22f;

		public Vector3 Axis = Vector3.up;

		private Rigidbody _rb;

		private void Awake()
		{
			_rb = ((Component)this).GetComponent<Rigidbody>();
		}

		private void FixedUpdate()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_rb == (Object)null))
			{
				_rb.MoveRotation(_rb.rotation * Quaternion.AngleAxis(DegPerSec * Time.fixedDeltaTime, ((Vector3)(ref Axis)).normalized));
			}
		}
	}
	internal sealed class PvpMovePad : MonoBehaviour
	{
		public Vector3 LocalA;

		public Vector3 LocalB;

		public float Period = 5f;

		public float Phase;

		public float Radius;

		private Rigidbody _rb;

		private Transform _space;

		private void Awake()
		{
			_rb = ((Component)this).GetComponent<Rigidbody>();
			_space = ((Component)this).transform.parent;
		}

		private void FixedUpdate()
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_rb == (Object)null) && !((Object)(object)_space == (Object)null))
			{
				Vector3 val;
				if (Radius > 0.05f)
				{
					float num = Time.time / Mathf.Max(0.2f, Period) * (float)Math.PI * 2f + Phase;
					val = LocalA + new Vector3(Mathf.Cos(num) * Radius, 0f, Mathf.Sin(num) * Radius);
				}
				else
				{
					float num2 = 0.5f + 0.5f * Mathf.Sin(Time.time / Mathf.Max(0.2f, Period) * (float)Math.PI * 2f + Phase);
					val = Vector3.Lerp(LocalA, LocalB, num2);
				}
				_rb.MovePosition(_space.TransformPoint(val));
			}
		}
	}
	internal sealed class PvpFallPad : MonoBehaviour
	{
		public float Delay = 0.55f;

		private bool _armed;

		private float _dropAt;

		private Rigidbody _rb;

		private void Awake()
		{
			_rb = ((Component)this).GetComponent<Rigidbody>();
		}

		private void OnCollisionStay(Collision col)
		{
			if (col != null)
			{
				TryArm(col.collider);
			}
		}

		private void OnTriggerStay(Collider col)
		{
			TryArm(col);
		}

		private void TryArm(Collider col)
		{
			if (!_armed && !((Object)(object)col == (Object)null) && !(Time.time < PvpSession.ProtectUntil) && !((Object)(object)((Component)col).GetComponentInParent<Player>() == (Object)null))
			{
				_armed = true;
				_dropAt = Time.time + Delay;
			}
		}

		private void Update()
		{
			if (_armed && !((Object)(object)_rb == (Object)null) && !(Time.time < _dropAt))
			{
				_rb.isKinematic = false;
				_rb.useGravity = true;
				_rb.constraints = (RigidbodyConstraints)0;
				((Behaviour)this).enabled = false;
				Object.Destroy((Object)(object)((Component)this).gameObject, 10f);
			}
		}
	}
	internal static class PvpBalance
	{
		private const float SkyAboveWater = 26f;

		private const float BenchAlong = 1.85f;

		private const float JumpGap = 1.7f;

		private const float StandHeight = 1.12f;

		private static GameObject _root;

		private static readonly List<GameObject> _pads = new List<GameObject>();

		private static Mesh _cachedMesh;

		private static Material[] _cachedMats;

		private static readonly List<Renderer> _hiddenRends = new List<Renderer>();

		private static readonly List<Collider> _hiddenCols = new List<Collider>();

		private static Vector3 _along = Vector3.forward;

		private static GameObject _template;

		private static int _layer;

		private static float _yaw;

		internal static int PadCount => _pads.Count;

		internal static bool IsActive => (Object)(object)_root != (Object)null;

		internal static bool TryGetSpawn(out Vector3 pos, out float yaw)
		{
			return TryGetSlot(0, Mathf.Max(1, _pads.Count), out pos, out yaw);
		}

		internal static bool TryGetSlot(int slot, int count, out Vector3 pos, out float yaw)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			pos = Vector3.zero;
			yaw = _yaw;
			if ((Object)(object)_root == (Object)null)
			{
				return false;
			}
			if (_pads.Count == 0)
			{
				Build(Mathf.Max(1, count));
			}
			if (_pads.Count == 0)
			{
				return false;
			}
			int index = PlayerPadIndex(slot, Mathf.Max(1, count));
			pos = StandPos(_pads[index]);
			yaw = _yaw;
			return true;
		}

		private static int PlayerPadIndex(int slot, int players)
		{
			int count = _pads.Count;
			if (count <= 1)
			{
				return 0;
			}
			if (players <= 1)
			{
				return count / 2;
			}
			if (slot < 0)
			{
				slot = 0;
			}
			if (slot >= players)
			{
				slot = players - 1;
			}
			return Mathf.RoundToInt((float)slot * ((float)count - 1f) / ((float)players - 1f));
		}

		internal static void Destroy()
		{
			_pads.Clear();
			RestoreIsland();
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
			}
			_root = null;
			_template = null;
		}

		internal unsafe static bool Build(int playerCount)
		{
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			Destroy();
			_template = FindBenchTemplate();
			if ((Object)(object)_template == (Object)null)
			{
				Debug.LogWarning((object)"[HowToFishPvp] BenchSmall not found; using stand-in.");
			}
			if (!TryIslandSpawn(out var pos, out var yaw))
			{
				pos = ((!((Object)(object)Player.LocalPlayer != (Object)null) || !((Object)(object)Player.LocalPlayer.Transform != (Object)null)) ? Vector3.zero : Player.LocalPlayer.Transform.position);
			}
			_yaw = yaw;
			_layer = FirstJumpLayer();
			float num = 0f;
			try
			{
				num = WaterManager.GetWaterHeight(pos);
			}
			catch
			{
				try
				{
					num = WaterManager.WaterHeight;
				}
				catch
				{
				}
			}
			Vector3 val = FindOpenWater(pos, num);
			float num2 = num + 26f;
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(val.x, num2, val.z);
			_along = val - pos;
			_along.y = 0f;
			if (((Vector3)(ref _along)).sqrMagnitude < 1f)
			{
				_along = Vector3.forward;
			}
			((Vector3)(ref _along)).Normalize();
			_yaw = Mathf.Atan2(_along.x, _along.z) * 57.29578f;
			_root = new GameObject("HowToFishPvpBalance");
			_root.layer = _layer;
			try
			{
				_root.tag = "Level";
			}
			catch
			{
			}
			_root.transform.position = val2;
			_root.transform.rotation = Quaternion.identity;
			_root.transform.localScale = Vector3.one;
			MoveToIslandScene(_root);
			int num3 = BenchCount(playerCount);
			float num4 = 3.5500002f;
			Vector3 val3 = val2 - _along * ((float)(num3 - 1) * 0.5f * num4);
			Quaternion rot = Quaternion.LookRotation(_along);
			for (int i = 0; i < num3; i++)
			{
				_pads.Add(MakeBench(val3 + _along * ((float)i * num4), rot));
			}
			HideIsland();
			Physics.SyncTransforms();
			Debug.Log((object)("[HowToFishPvp] Sky benches " + num3 + " over water at " + ((object)(*(Vector3*)(&val2))/*cast due to .constrained prefix*/).ToString()));
			return true;
		}

		private static Vector3 StandPos(GameObject bench)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)bench == (Object)null)
			{
				return Vector3.zero;
			}
			return bench.transform.position + Vector3.up * 1.12f;
		}

		private static bool IsOurObject(Transform t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return true;
			}
			if ((Object)(object)_root != (Object)null && ((Object)(object)t == (Object)(object)_root.transform || t.IsChildOf(_root.transform)))
			{
				return true;
			}
			string text = ((Object)((Component)t).gameObject).name.ToLowerInvariant();
			if (text.IndexOf("howtofish") < 0 && text.IndexOf("balancebench") < 0)
			{
				return text.IndexOf("benchclone") >= 0;
			}
			return true;
		}

		private static GameObject FindBenchTemplate()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val = GameObject.Find("BenchSmall");
				if ((Object)(object)val != (Object)null && !IsOurObject(val.transform))
				{
					return val;
				}
			}
			catch
			{
			}
			GameObject result = null;
			int num = 99;
			Transform[] array = Object.FindObjectsOfType<Transform>();
			if (array == null)
			{
				return null;
			}
			foreach (Transform val2 in array)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				Scene scene = ((Component)val2).gameObject.scene;
				if (!((Scene)(ref scene)).isLoaded || IsOurObject(val2))
				{
					continue;
				}
				string text = ((Object)((Component)val2).gameObject).name.ToLowerInvariant();
				if (text.IndexOf("bench") >= 0)
				{
					int num2 = ((text.IndexOf("benchsmall") < 0) ? 2 : 0);
					if ((Object)(object)((Component)val2).GetComponentInChildren<MeshFilter>() == (Object)null && (Object)(object)((Component)val2).GetComponentInChildren<MeshRenderer>() == (Object)null)
					{
						num2 += 5;
					}
					if (num2 < num)
					{
						num = num2;
						result = ((Component)val2).gameObject;
					}
					if (num2 == 0)
					{
						return ((Component)val2).gameObject;
					}
				}
			}
			return result;
		}

		private static int BenchCount(int playerCount)
		{
			return Mathf.Clamp(Mathf.Max(playerCount, 1) + 5, 6, 10);
		}

		private static GameObject MakeBench(Vector3 pos, Quaternion rot)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("BalanceBench");
			val.layer = _layer;
			try
			{
				val.tag = "Level";
			}
			catch
			{
			}
			val.transform.SetParent(_root.transform, true);
			val.transform.position = pos;
			val.transform.rotation = rot;
			val.transform.localScale = Vector3.one;
			CopyVisuals(_template, val);
			BoxCollider obj2 = val.AddComponent<BoxCollider>();
			((Collider)obj2).isTrigger = false;
			obj2.center = new Vector3(0f, 0.22f, 0f);
			obj2.size = new Vector3(1.9f, 0.48f, 0.58f);
			return val;
		}

		private static int CopyVisuals(GameObject template, GameObject dest)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			Mesh val = FindBenchMesh(template);
			Material[] mats = FindBenchMaterials(template);
			if ((Object)(object)val != (Object)null)
			{
				AddMeshPart(dest, val, mats, BenchScale(val, template));
				return 1;
			}
			Debug.LogWarning((object)"[HowToFishPvp] No readable bench mesh; using wood stand-in.");
			return MakeTexturedStandIn(dest, mats);
		}

		private static Mesh FindBenchMesh(GameObject template)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_cachedMesh != (Object)null)
			{
				return _cachedMesh;
			}
			if ((Object)(object)template != (Object)null)
			{
				MeshFilter[] componentsInChildren = template.GetComponentsInChildren<MeshFilter>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Mesh val = (((Object)(object)componentsInChildren[i] != (Object)null) ? componentsInChildren[i].sharedMesh : null);
					if (UsableMesh(val))
					{
						_cachedMesh = val;
						return val;
					}
				}
				MeshCollider[] componentsInChildren2 = template.GetComponentsInChildren<MeshCollider>(true);
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					Mesh val2 = (((Object)(object)componentsInChildren2[j] != (Object)null) ? componentsInChildren2[j].sharedMesh : null);
					if (UsableMesh(val2))
					{
						_cachedMesh = val2;
						return val2;
					}
				}
			}
			Mesh val3 = null;
			float num = 9999f;
			Vector3 val4 = Vector3.zero;
			bool flag = false;
			Bounds val5;
			if ((Object)(object)template != (Object)null)
			{
				Renderer componentInChildren = template.GetComponentInChildren<Renderer>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					val5 = componentInChildren.localBounds;
					val4 = ((Bounds)(ref val5)).size;
					flag = ((Vector3)(ref val4)).sqrMagnitude > 0.01f;
				}
			}
			Mesh[] array = Resources.FindObjectsOfTypeAll<Mesh>();
			if (array == null)
			{
				return null;
			}
			foreach (Mesh val6 in array)
			{
				if (!UsableMesh(val6))
				{
					continue;
				}
				val5 = val6.bounds;
				Vector3 size = ((Bounds)(ref val5)).size;
				if (LooksLikeBench(size))
				{
					float num2 = BenchScore(val6, size, flag ? val4 : size);
					if (num2 < num)
					{
						num = num2;
						val3 = val6;
					}
				}
			}
			_cachedMesh = val3;
			if ((Object)(object)val3 != (Object)null)
			{
				string[] obj = new string[6]
				{
					"[HowToFishPvp] Bench mesh ",
					((Object)val3).name,
					" verts=",
					val3.vertexCount.ToString(),
					" size=",
					null
				};
				val5 = val3.bounds;
				obj[5] = ((object)((Bounds)(ref val5)).size/*cast due to .constrained prefix*/).ToString();
				Debug.Log((object)string.Concat(obj));
			}
			return val3;
		}

		private static bool UsableMesh(Mesh m)
		{
			if ((Object)(object)m == (Object)null)
			{
				return false;
			}
			string name = ((Object)m).name;
			if (name.IndexOf("Combined", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return false;
			}
			if (name.IndexOf("batch", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return false;
			}
			if (m.vertexCount < 12 || m.vertexCount > 20000)
			{
				return false;
			}
			return true;
		}

		private static bool LooksLikeBench(Vector3 s)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(s.x, s.z);
			float num2 = Mathf.Min(s.x, s.z);
			if (num >= 0.6f && num <= 4.5f && num2 >= 0.18f && num2 <= 1.8f && s.y >= 0.12f)
			{
				return s.y <= 1.8f;
			}
			return false;
		}

		private static float BenchScore(Mesh m, Vector3 size, Vector3 want)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Vector3 val = size - want;
			float num = ((Vector3)(ref val)).sqrMagnitude;
			string text = ((Object)m).name.ToLowerInvariant();
			if (text.IndexOf("bench") >= 0)
			{
				num -= 50f;
			}
			if (text.IndexOf("seat") >= 0 || text.IndexOf("wood") >= 0)
			{
				num -= 8f;
			}
			return num;
		}

		private static Vector3 BenchScale(Mesh mesh, GameObject template)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0069: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			Bounds bounds = mesh.bounds;
			Vector3 size = ((Bounds)(ref bounds)).size;
			float num = Mathf.Max(size.x, size.z);
			float num2 = 1f;
			if (num > 6f)
			{
				num2 = 1.9f / num;
			}
			else if (num < 0.25f)
			{
				num2 = 1.9f / Mathf.Max(num, 0.01f);
			}
			if ((Object)(object)template != (Object)null)
			{
				Vector3 lossyScale = template.transform.lossyScale;
				float num3 = Mathf.Max(Mathf.Abs(lossyScale.x), Mathf.Abs(lossyScale.z));
				if (num3 > 0.01f && num3 < 8f && num >= 0.25f && num <= 6f)
				{
					return lossyScale;
				}
			}
			return Vector3.one * num2;
		}

		private static Material[] FindBenchMaterials(GameObject template)
		{
			if (_cachedMats != null && _cachedMats.Length != 0)
			{
				return _cachedMats;
			}
			if ((Object)(object)template != (Object)null)
			{
				Renderer[] componentsInChildren = template.GetComponentsInChildren<Renderer>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if (!((Object)(object)componentsInChildren[i] == (Object)null) && componentsInChildren[i].sharedMaterials != null && componentsInChildren[i].sharedMaterials.Length != 0)
					{
						_cachedMats = componentsInChildren[i].sharedMaterials;
						return _cachedMats;
					}
				}
			}
			return _cachedMats;
		}

		private static void AddMeshPart(GameObject dest, Mesh mesh, Material[] mats, Vector3 scale)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_0057: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("BenchMesh")
			{
				layer = dest.layer
			};
			val.transform.SetParent(dest.transform, false);
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.Euler(-90f, 0f, 0f);
			val.transform.localScale = scale;
			val.AddComponent<MeshFilter>().sharedMesh = mesh;
			MeshRenderer val2 = val.AddComponent<MeshRenderer>();
			((Renderer)val2).enabled = true;
			((Renderer)val2).shadowCastingMode = (ShadowCastingMode)1;
			((Renderer)val2).receiveShadows = true;
			((Renderer)val2).lightmapIndex = -1;
			((Renderer)val2).realtimeLightmapIndex = -1;
			if (mats != null && mats.Length != 0)
			{
				((Renderer)val2).sharedMaterials = mats;
			}
		}

		private static int MakeTexturedStandIn(GameObject dest, Material[] mats)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			AddBox(dest, new Vector3(0f, 0.4f, 0f), new Vector3(1.85f, 0.08f, 0.52f), mats);
			AddBox(dest, new Vector3(-0.82f, 0.18f, 0.18f), new Vector3(0.09f, 0.36f, 0.09f), mats);
			AddBox(dest, new Vector3(0.82f, 0.18f, 0.18f), new Vector3(0.09f, 0.36f, 0.09f), mats);
			AddBox(dest, new Vector3(-0.82f, 0.18f, -0.18f), new Vector3(0.09f, 0.36f, 0.09f), mats);
			AddBox(dest, new Vector3(0.82f, 0.18f, -0.18f), new Vector3(0.09f, 0.36f, 0.09f), mats);
			AddBox(dest, new Vector3(0f, 0.62f, -0.22f), new Vector3(1.85f, 0.28f, 0.08f), mats);
			return 6;
		}

		private static void AddBox(GameObject dest, Vector3 localPos, Vector3 size, Material[] mats)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)obj).name = "BenchPart";
			obj.layer = dest.layer;
			Object.Destroy((Object)(object)obj.GetComponent<Collider>());
			obj.transform.SetParent(dest.transform, false);
			obj.transform.localPosition = localPos;
			obj.transform.localRotation = Quaternion.identity;
			obj.transform.localScale = size;
			MeshRenderer component = obj.GetComponent<MeshRenderer>();
			((Renderer)component).enabled = true;
			((Renderer)component).lightmapIndex = -1;
			if (mats != null && mats.Length != 0)
			{
				((Renderer)component).sharedMaterials = mats;
			}
		}

		private static Bounds LocalMeshBounds(GameObject go)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			MeshFilter[] componentsInChildren = go.GetComponentsInChildren<MeshFilter>(true);
			Bounds result = default(Bounds);
			((Bounds)(ref result))..ctor(Vector3.zero, Vector3.zero);
			bool flag = false;
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (!((Object)(object)componentsInChildren[i] == (Object)null) && !((Object)(object)componentsInChildren[i].sharedMesh == (Object)null))
				{
					Bounds bounds = componentsInChildren[i].sharedMesh.bounds;
					if (!flag)
					{
						result = bounds;
						flag = true;
					}
					else
					{
						((Bounds)(ref result)).Encapsulate(bounds);
					}
				}
			}
			if (!flag)
			{
				return new Bounds(Vector3.zero, Vector3.zero);
			}
			return result;
		}

		private static Vector3 FindOpenWater(Vector3 island, float water)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			try
			{
				num = LayerMask.op_Implicit(GameInfo.LevelLayer);
			}
			catch
			{
			}
			try
			{
				num |= LayerMask.op_Implicit(GameInfo.CanJumpOnLayers);
			}
			catch
			{
			}
			if (num == 0)
			{
				num = -5;
			}
			Vector3[] obj3 = new Vector3[8]
			{
				Vector3.forward,
				Vector3.back,
				Vector3.right,
				Vector3.left,
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3)
			};
			Vector3 val = Vector3.forward + Vector3.right;
			obj3[4] = ((Vector3)(ref val)).normalized;
			val = Vector3.forward + Vector3.left;
			obj3[5] = ((Vector3)(ref val)).normalized;
			val = Vector3.back + Vector3.right;
			obj3[6] = ((Vector3)(ref val)).normalized;
			val = Vector3.back + Vector3.left;
			obj3[7] = ((Vector3)(ref val)).normalized;
			Vector3[] array = (Vector3[])(object)obj3;
			float[] array2 = new float[4] { 70f, 100f, 140f, 180f };
			Vector3 result = island + Vector3.right * 120f;
			for (int i = 0; i < array2.Length; i++)
			{
				for (int j = 0; j < array.Length; j++)
				{
					Vector3 val2 = island + array[j] * array2[i];
					if (!LandAt(val2, water, num))
					{
						return val2;
					}
				}
			}
			return result;
		}

		private static bool LandAt(Vector3 xz, float water, int mask)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (!Physics.Raycast(xz + Vector3.up * 80f, Vector3.down, ref val, 130f, mask, (QueryTriggerInteraction)1))
			{
				return false;
			}
			return ((RaycastHit)(ref val)).point.y > water + 1.8f;
		}

		private static void HideIsland()
		{
			RestoreIsland();
			Transform waterXf = null;
			try
			{
				object value = AccessTools.Field(typeof(WaterManager), "_instance").GetValue(null);
				if (value != null)
				{
					object? value2 = AccessTools.Field(typeof(WaterManager), "_mainWater").GetValue(value);
					waterXf = (Transform)((value2 is Transform) ? value2 : null);
				}
			}
			catch
			{
			}
			Renderer[] array = Object.FindObjectsOfType<Renderer>();
			if (array == null)
			{
				return;
			}
			foreach (Renderer val in array)
			{
				if (!((Object)(object)val == (Object)null) && val.enabled && !KeepVisible(((Component)val).transform, waterXf))
				{
					val.enabled = false;
					_hiddenRends.Add(val);
				}
			}
			Collider[] array2 = Object.FindObjectsOfType<Collider>();
			if (array2 == null)
			{
				return;
			}
			foreach (Collider val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null) && val2.enabled && !val2.isTrigger && !KeepVisible(((Component)val2).transform, waterXf))
				{
					val2.enabled = false;
					_hiddenCols.Add(val2);
				}
			}
		}

		private static bool KeepVisible(Transform t, Transform waterXf)
		{
			if ((Object)(object)t == (Object)null)
			{
				return true;
			}
			if (IsOurObject(t))
			{
				return true;
			}
			if ((Object)(object)waterXf != (Object)null && ((Object)(object)t == (Object)(object)waterXf || t.IsChildOf(waterXf) || waterXf.IsChildOf(t)))
			{
				return true;
			}
			if ((Object)(object)((Component)t).GetComponentInParent<Player>() != (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)t).GetComponentInParent<Item>() != (Object)null)
			{
				return true;
			}
			string text = ((Object)((Component)t).gameObject).name.ToLowerInvariant();
			if (text.IndexOf("water") >= 0 || text.IndexOf("ocean") >= 0 || text.IndexOf("sea") >= 0)
			{
				return true;
			}
			if (text.IndexOf("wave") >= 0 || text.IndexOf("foam") >= 0 || text.IndexOf("horizon") >= 0)
			{
				return true;
			}
			if (text.IndexOf("sky") >= 0 || text.IndexOf("cloud") >= 0 || text.IndexOf("sun") >= 0)
			{
				return true;
			}
			return false;
		}

		private static void RestoreIsland()
		{
			for (int i = 0; i < _hiddenRends.Count; i++)
			{
				if ((Object)(object)_hiddenRends[i] != (Object)null)
				{
					_hiddenRends[i].enabled = true;
				}
			}
			_hiddenRends.Clear();
			for (int j = 0; j < _hiddenCols.Count; j++)
			{
				if ((Object)(object)_hiddenCols[j] != (Object)null)
				{
					_hiddenCols[j].enabled = true;
				}
			}
			_hiddenCols.Clear();
		}

		private static void MoveToIslandScene(GameObject go)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)Island.CurIsland != (Object)null)
				{
					SceneManager.MoveGameObjectToScene(go, ((Component)Island.CurIsland).gameObject.scene);
				}
			}
			catch
			{
			}
		}

		private static int FirstJumpLayer()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			try
			{
				num = LayerMask.op_Implicit(GameInfo.CanJumpOnLayers);
			}
			catch
			{
			}
			for (int i = 0; i < 32; i++)
			{
				if ((num & (1 << i)) != 0)
				{
					return i;
				}
			}
			try
			{
				int num2 = LayerMask.op_Implicit(GameInfo.LevelLayer);
				for (int j = 0; j < 32; j++)
				{
					if ((num2 & (1 << j)) != 0)
					{
						return j;
					}
				}
			}
			catch
			{
			}
			return 0;
		}

		private static bool TryIslandSpawn(out Vector3 pos, out float yaw)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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)
			pos = Vector3.zero;
			yaw = 0f;
			try
			{
				SpawnManager[] array = Object.FindObjectsOfType<SpawnManager>();
				if (array == null)
				{
					return false;
				}
				foreach (SpawnManager val in array)
				{
					if ((Object)(object)val == (Object)null || !((Behaviour)val).isActiveAndEnabled)
					{
						continue;
					}
					object? value = AccessTools.Field(typeof(SpawnManager), "_playerSpawnPoint").GetValue(val);
					Transform val2 = (Transform)((value is Transform) ? value : null);
					if (!((Object)(object)val2 == (Object)null))
					{
						pos = val2.position;
						yaw = val2.eulerAngles.y;
						if (((Vector3)(ref pos)).sqrMagnitude > 0.01f)
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class PvpBoats
	{
		private static readonly List<Boat> _fight = new List<Boat>();

		private static readonly List<Vector3> _slotPos = new List<Vector3>();

		private static readonly List<Quaternion> _slotRot = new List<Quaternion>();

		private static Boat _redirect;

		private static Player _inputPlayer;

		private static bool _wiping;

		private static bool _held;

		private static bool _live;

		internal static bool IsRound => _live;

		internal static bool Keep(Boat boat)
		{
			if ((Object)(object)boat == (Object)null)
			{
				return false;
			}
			if (IsFight(boat))
			{
				return true;
			}
			if (!IsRound)
			{
				return false;
			}
			try
			{
				if (((Object)((Component)boat).gameObject).name.IndexOf("PvpFight") >= 0)
				{
					return true;
				}
			}
			catch
			{
			}
			if (IsRound)
			{
				return !NearDock(boat);
			}
			return false;
		}

		internal static bool KeepGo(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return false;
			}
			try
			{
				Boat componentInParent = go.GetComponentInParent<Boat>();
				if ((Object)(object)componentInParent != (Object)null)
				{
					return Keep(componentInParent);
				}
			}
			catch
			{
			}
			if (!IsRound)
			{
				return false;
			}
			for (int i = 0; i < _fight.Count; i++)
			{
				if (OwnsGo(_fight[i], go))
				{
					return true;
				}
			}
			return false;
		}

		private static bool OwnsGo(Boat boat, GameObject go)
		{
			if ((Object)(object)boat == (Object)null || (Object)(object)go == (Object)null)
			{
				return false;
			}
			Transform transform = go.transform;
			try
			{
				if ((Object)(object)transform == (Object)(object)((Component)boat).transform || transform.IsChildOf(((Component)boat).transform))
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)boat.VisualBoat != (Object)null && ((Object)(object)transform == (Object)(object)boat.VisualBoat || transform.IsChildOf(boat.VisualBoat)))
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)boat.HiddenPhysicsRig != (Object)null)
				{
					Transform transform2 = ((Component)boat.HiddenPhysicsRig).transform;
					if ((Object)(object)transform == (Object)(object)transform2 || transform.IsChildOf(transform2) || transform2.IsChildOf(transform))
					{
						return true;
					}
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)boat.VisualPhysicsRig != (Object)null)
				{
					Transform transform3 = ((Component)boat.VisualPhysicsRig).transform;
					if ((Object)(object)transform == (Object)(object)transform3 || transform.IsChildOf(transform3))
					{
						return true;
					}
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)boat.BoatTrigger != (Object)null && ((Object)(object)go == (Object)(object)((Component)boat.BoatTrigger).gameObject || transform.IsChildOf(((Component)boat.BoatTrigger).transform)))
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				object? value = AccessTools.Field(typeof(Boat), "_dynamicObjectColsHolder").GetValue(boat);
				Transform val = (Transform)((value is Transform) ? value : null);
				if ((Object)(object)val != (Object)null && ((Object)(object)transform == (Object)(object)val || transform.IsChildOf(val)))
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		internal static void Build(int players, Vector3 center, float water)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Wipe();
			_live = true;
			try
			{
				ServerSaveObject curServerSave = SaveManager.CurServerSave;
				if (curServerSave != null)
				{
					curServerSave.UnlockedBoat = true;
				}
			}
			catch
			{
			}
			if (IsHost())
			{
				SpawnAll(Mathf.Max(2, players), center, water);
			}
			BindLive();
		}

		internal static void Tick()
		{
			if (IsRound)
			{
				BindLive();
				UnlockAll();
				if (PvpSession.Phase == PvpPhase.Countdown)
				{
					Hold(freeze: true);
					SnapSlots();
				}
			}
		}

		internal static void Hold(bool freeze)
		{
			_held = freeze;
			if (freeze)
			{
				SnapSlots();
			}
			for (int i = 0; i < _fight.Count; i++)
			{
				FreezeRig(_fight[i], freeze);
			}
		}

		internal static void SeatPlayers()
		{
			if (IsRound)
			{
				Hold(freeze: false);
				UnlockAll();
			}
		}

		internal static bool IsStandingOnBoat(Player player)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (!IsRound || (Object)(object)player == (Object)null)
			{
				return false;
			}
			Boat val = NearPlayer(player, 5.5f);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Vector3 zero = Vector3.zero;
			try
			{
				zero = ((!((Object)(object)player.Transform != (Object)null)) ? ((Component)player).transform.position : player.Transform.position);
			}
			catch
			{
				return false;
			}
			float y = StandOn(val).y;
			return zero.y > y - 0.9f;
		}

		internal static void Wipe()
		{
			_wiping = true;
			for (int i = 0; i < _fight.Count; i++)
			{
				Boat val = _fight[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					if (IsHost())
					{
						((NetworkBehaviour)Server.Instance).Despawn(((Component)val).gameObject, (DespawnType?)null);
					}
					else
					{
						Object.Destroy((Object)(object)((Component)val).gameObject);
					}
				}
				catch
				{
					try
					{
						Object.Destroy((Object)(object)((Component)val).gameObject);
					}
					catch
					{
					}
				}
			}
			_fight.Clear();
			_slotPos.Clear();
			_slotRot.Clear();
			_redirect = null;
			_inputPlayer = null;
			_held = false;
			_live = false;
			_wiping = false;
		}

		private static void SpawnAll(int count, Vector3 center, float water)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			Boat val = FindPrefab();
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)"[HowToFishPvp] No boat prefab for boat round.");
				return;
			}
			for (int i = 0; i < count; i++)
			{
				SlotPose(i, count, center, water, out var pos, out var rot);
				Boat val2 = SpawnOne(val, pos, rot, i);
				if (!((Object)(object)val2 == (Object)null))
				{
					_fight.Add(val2);
					_slotPos.Add(pos);
					_slotRot.Add(rot);
					UnlockOne(val2);
				}
			}
		}

		private static void SlotPose(int i, int count, Vector3 center, float water, out Vector3 pos, out Quaternion rot)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			float num = 8.5f;
			float num2;
			float num3;
			if (count <= 2)
			{
				num2 = ((count <= 1) ? 0f : ((i == 0) ? (-0.5f) : 0.5f)) * num;
				num3 = 0f;
			}
			else
			{
				int num4 = i % 2;
				int num5 = i / 2;
				num2 = ((float)num4 - 0.5f) * num;
				num3 = ((float)num5 - 0.5f) * num;
			}
			pos = new Vector3(center.x + num2, water, center.z + num3);
			rot = Quaternion.LookRotation(Vector3.forward);
		}

		private static Boat SpawnOne(Boat prefab, Vector3 pos, Quaternion rot, int index)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			Boat val = null;
			try
			{
				val = Object.Instantiate<Boat>(prefab, pos, rot);
			}
			catch
			{
				return null;
			}
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			((Object)((Component)val).gameObject).name = "PvpFightBoat" + index;
			((Component)val).gameObject.SetActive(true);
			try
			{
				if ((Object)(object)Island.CurIsland != (Object)null)
				{
					SceneManager.MoveGameObjectToScene(((Component)val).gameObject, ((Component)Island.CurIsland).gameObject.scene);
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)Server.Instance != (Object)null && ((NetworkBehaviour)Server.Instance).IsServerInitialized)
				{
					((NetworkBehaviour)Server.Instance).Spawn(((Component)val).gameObject, (NetworkConnection)null, default(Scene));
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[HowToFishPvp] Boat spawn failed: " + ex.Message));
			}
			SnapPose(val, pos, rot);
			ArmWalk(val);
			return val;
		}

		private static void BindLive()
		{
			try
			{
				Boat[] array = Object.FindObjectsOfType<Boat>();
				if (array == null)
				{
					return;
				}
				foreach (Boat val in array)
				{
					if (!((Object)(object)val == (Object)null) && !IsFight(val) && ((Component)val).gameObject.activeInHierarchy && !NearDock(val))
					{
						_fight.Add(val);
					}
				}
			}
			catch
			{
			}
			_fight.RemoveAll((Boat b) => (Object)(object)b == (Object)null);
			for (int num = 0; num < _fight.Count; num++)
			{
				Boat boat = _fight[num];
				UnlockOne(boat);
				ArmWalk(boat);
				MarkDeck(boat);
			}
		}

		private static void MarkDeck(Boat boat)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)boat == (Object)null)
			{
				return;
			}
			Transform val = (((Object)(object)boat.VisualBoat != (Object)null) ? boat.VisualBoat : ((Component)boat).transform);
			for (int i = 0; i < val.childCount; i++)
			{
				if (((Object)val.GetChild(i)).name == "PvpBoatSpawn")
				{
					return;
				}
			}
			Vector3 position = StandOn(boat);
			Transform transform = new GameObject("PvpBoatSpawn").transform;
			transform.SetParent(val, false);
			transform.position = position;
			PvpArena.AddSpawn(transform);
		}

		private static Vector3 StandOn(Boat boat)
		{
			//IL_0058: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Transform val = (((Object)(object)boat.VisualBoat != (Object)null) ? boat.VisualBoat : ((Component)boat).transform).Find("PvpBoatDeck");
				if ((Object)(object)val != (Object)null)
				{
					return val.position + Vector3.up * 0.45f;
				}
			}
			catch
			{
			}
			Vector3 position = ((Component)boat).transform.position;
			return new Vector3(position.x, position.y + 1.45f, position.z);
		}

		private static void UnlockAll()
		{
			for (int i = 0; i < _fight.Count; i++)
			{
				UnlockOne(_fight[i]);
			}
		}

		private static void UnlockOne(Boat boat)
		{
			if ((Object)(object)boat == (Object)null)
			{
				return;
			}
			try
			{
				boat.UnlockBoat();
			}
			catch
			{
			}
			try
			{
				BoatInteractable componentInChildren = ((Component)boat).GetComponentInChildren<BoatInteractable>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((Interactable)componentInChildren).ToggleIsInteractable(true);
				}
			}
			catch
			{
			}
		}

		private static void SnapSlots()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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)
			int num = Mathf.Min(_fight.Count, _slotPos.Count);
			for (int i = 0; i < num; i++)
			{
				if ((Object)(object)_fight[i] != (Object)null)
				{
					SnapPose(_fight[i], _slotPos[i], (i < _slotRot.Count) ? _slotRot[i] : Quaternion.identity);
				}
			}
		}

		private static void SnapPose(Boat boat, Vector3 pos, Quaternion rot)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)boat == (Object)null)
			{
				return;
			}
			try
			{
				((Component)boat).transform.position = pos;
				((Component)boat).transform.rotation = rot;
			}
			catch
			{
			}
			MoveRb(boat.HiddenPhysicsRig, pos, rot);
			MoveRb(boat.VisualPhysicsRig, pos, rot);
			try
			{
				if ((Object)(object)boat.VisualBoat != (Object)null)
				{
					boat.VisualBoat.position = pos;
					boat.VisualBoat.rotation = rot;
				}
			}
			catch
			{
			}
			try
			{
				object? value = AccessTools.Field(typeof(Boat), "_dynamicObjectColsHolder").GetValue(boat);
				Transform val = (Transform)((value is Transform) ? value : null);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(true);
					val.position = pos;
					val.rotation = rot;
				}
			}
			catch
			{
			}
			try
			{
				object? value2 = AccessTools.Field(typeof(Boat), "_itemColsHolder").GetValue(boat);
				MoveRb((Rigidbody)((value2 is Rigidbody) ? value2 : null), pos, rot);
			}
			catch
			{
			}
			SetBoatField(boat, "_curLerpedPos", pos);
			SetBoatField(boat, "_lastPos", pos);
			SetBoatField(boat, "_lastFramePos", pos);
			SetBoatField(boat, "_serverPos", pos);
			SetBoatField(boat, "_curLerpedRot", rot);
			SetBoatField(boat, "_lastRot", rot);
			SetBoatField(boat, "_lastFrameRot", rot);
			SetBoatField(boat, "_serverRot", ((Quaternion)(ref rot)).eulerAngles);
		}

		private static void MoveRb(Rigidbody rb, Vector3 pos, Quaternion rot)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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)
			if ((Object)(object)rb == (Object)null)
			{
				return;
			}
			try
			{
				((Component)rb).gameObject.SetActive(true);
				rb.linearVelocity = Vector3.zero;
				rb.angularVelocity = Vector3.zero;
				rb.position = pos;
				rb.rotation = rot;
				((Component)rb).transform.position = pos;
				((Component)rb).transform.rotation = rot;
			}
			catch
			{
			}
		}

		private static void SetBoatField(Boat boat, string name, object value)
		{
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(Boat), name);
				if (fieldInfo != null)
				{
					fieldInfo.SetValue(boat, value);
				}
			}
			catch
			{
			}
		}

		private static void ArmWalk(Boat boat)
		{
			if ((Object)(object)boat == (Object)null)
			{
				return;
			}
			AddDeck(boat);
			try
			{
				object? value = AccessTools.Field(typeof(Boat), "_dynamicObjectColsHolder").GetValue(boat);
				Transform val = (Transform)((value is Transform) ? value : null);
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(true);
					Collider[] componentsInChildren = ((Component)val).GetComponentsInChildren<Collider>(true);
					if (componentsInChildren != null)
					{
						for (int i = 0; i < componentsInChildren.Length; i++)
						{
							if ((Object)(object)componentsInChildren[i] != (Object)null)
							{
								componentsInChildren[i].enabled = true;
							}
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Collider[] array = CollectCols(boat);
				if (array.Length != 0)
				{
					BoatManager.SetBoat(array, boat);
				}
			}
			catch
			{
			}
		}

		private static void AddDeck(Boat boat)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			Transform val = null;
			try
			{
				val = boat.VisualBoat;
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)boat).transform;
			}
			Transform val2 = val.Find("PvpBoatDeck");
			if ((Object)(object)val2 != (Object)null)
			{
				((Component)val2).gameObject.SetActive(true);
				val2.position = new Vector3(val.position.x, val.position.y + 1.02f, val.position.z);
				val2.rotation = val.rotation;
				BoxCollider component = ((Component)val2).GetComponent<BoxCollider>();
				if ((Object)(object)component != (Object)null)
				{
					((Collider)component).enabled = true;
					((Collider)component).isTrigger = false;
					component.size = new Vector3(3.6f, 0.12f, 1.8f);
					component.center = Vector3.zero;
				}
				return;
			}
			if (!DeckBounds(boat, out var bounds))
			{
				((Bounds)(ref bounds))..ctor(val.position + Vector3.up * 0.9f, new Vector3(5.6f, 0.7f, 2.4f));
			}
			GameObject val3 = new GameObject("PvpBoatDeck")
			{
				layer = Mathf.Max(0, BoatLayerIndex())
			};
			val3.transform.SetParent(val, true);
			float num = val.position.y + 1.02f;
			val3.transform.position = new Vector3(val.position.x, num, val.position.z);
			val3.transform.rotation = val.rotation;
			BoxCollider obj2 = val3.AddComponent<BoxCollider>();
			obj2.size = new Vector3(Mathf.Max(3.2f, Mathf.Min(((Bounds)(ref bounds)).size.x, 6.2f) * 0.7f), 0.12f, Mathf.Max(1.5f, Mathf.Min(((Bounds)(ref bounds)).size.z, 3.2f) * 0.7f));
			obj2.center = Vector3.zero;
			((Collider)obj2).isTrigger = false;
			((Collider)obj2).enabled = true;
		}

		private static bool DeckBounds(Boat boat, out Bounds bounds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			bounds = default(Bounds);
			bool flag = false;
			Transform val = null;
			try
			{
				val = boat.VisualBoat;
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)boat).transform;
			}
			Renderer[] componentsInChildren = ((Component)val).GetComponentsInChildren<Renderer>();
			if (componentsInChildren != null)
			{
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if (!((Object)(object)componentsInChildren[i] == (Object)null) && componentsInChildren[i].enabled)
					{
						if (!flag)
						{
							bounds = componentsInChildren[i].bounds;
							flag = true;
						}
						else
						{
							((Bounds)(ref bounds)).Encapsulate(componentsInChildren[i].bounds);
						}
					}
				}
			}
			if (flag)
			{
				return true;
			}
			Collider[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<Collider>();
			if (componentsInChildren2 == null)
			{
				return false;
			}
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				if (!((Object)(object)componentsInChildren2[j] == (Object)null) && !componentsInChildren2[j].isTrigger)
				{
					if (!flag)
					{
						bounds = componentsInChildren2[j].bounds;
						flag = true;
					}
					else
					{
						((Bounds)(ref bounds)).Encapsulate(componentsInChildren2[j].bounds);
					}
				}
			}
			return flag;
		}

		private static Collider[] CollectCols(Boat boat)
		{
			List<Collider> list = new List<Collider>();
			AddCols(list, ((Component)boat).gameObject);
			try
			{
				if ((Object)(object)boat.VisualBoat != (Object)null)
				{
					AddCols(list, ((Component)boat.VisualBoat).gameObject);
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)boat.HiddenPhysicsRig != (Object)null)
				{
					AddCols(list, ((Component)boat.HiddenPhysicsRig).gameObject);
				}
			}
			catch
			{
			}
			return list.ToArray();
		}

		private static void AddCols(List<Collider> list, GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			Collider[] componentsInChildren = go.GetComponentsInChildren<Collider>(true);
			if (componentsInChildren == null)
			{
				return;
			}
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if ((Object)(object)componentsInChildren[i] != (Object)null && !list.Contains(componentsInChildren[i]))
				{
					list.Add(componentsInChildren[i]);
				}
			}
		}

		private static int BoatLayerIndex()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				LayerMask boatLayer = GameInfo.BoatLayer;
				int value = ((LayerMask)(ref boatLayer)).value;
				for (int i = 0; i < 32; i++)
				{
					if ((value & (1 << i)) != 0)
					{
						return i;
					}
				}
			}
			catch
			{
			}
			int num = LayerMask.NameToLayer("Boat");
			if (num < 0)
			{
				return 0;
			}
			return num;
		}

		private static void FreezeRig(Boat boat, bool freeze)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)boat == (Object)null)
			{
				return;
			}
			try
			{
				Rigidbody hiddenPhysicsRig = boat.HiddenPhysicsRig;
				if (!((Object)(object)hiddenPhysicsRig == (Object)null))
				{
					if (freeze)
					{
						hiddenPhysicsRig.linearVelocity = Vector3.zero;
						hiddenPhysicsRig.angularVelocity = Vector3.zero;
					}
					if (((NetworkBehaviour)boat).IsServerInitialized)
					{
						hiddenPhysicsRig.isKinematic = freeze;
					}
				}
			}
			catch
			{
			}
		}

		private static Boat FindPrefab()
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				SpawnManager[] array = Object.FindObjectsOfType<SpawnManager>();
				if (array != null)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(SpawnManager), "_boatPrefab");
					for (int i = 0; i < array.Length; i++)
					{
						if (!((Object)(object)array[i] == (Object)null) && !(fieldInfo == null))
						{
							object? value = fieldInfo.GetValue(array[i]);
							Boat val = (Boat)((value is Boat) ? value : null);
							if ((Object)(object)val != (Object)null)
							{
								return val;
							}
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Boat[] array2 = Resources.FindObjectsOfTypeAll<Boat>();
				if (array2 != null)
				{
					foreach (Boat val2 in array2)
					{
						if (!((Object)(object)val2 == (Object)null))
						{
							Scene scene = ((Component)val2).gameObject.scene;
							if (!((Scene)(ref scene)).IsValid())
							{
								return val2;
							}
						}
					}
				}
			}
			catch
			{
			}
			return BoatManager.Boat;
		}

		private static bool NearDock(Boat boat)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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)
			if ((Object)(object)boat == (Object)null)
			{
				return false;
			}
			try
			{
				Vector3 boatSpawnPos = SpawnManager.BoatSpawnPos;
				Vector3 position = ((Component)boat).transform.position;
				boatSpawnPos.y = 0f;
				position.y = 0f;
				if (((Vector3)(ref boatSpawnPos)).sqrMagnitude < 0.01f)
				{
					return false;
				}
				Vector3 val = position - boatSpawnPos;
				return ((Vector3)(ref val)).sqrMagnitude < 400f;
			}
			catch
			{
				return false;
			}
		}

		private static bool IsFight(Boat boat)
		{
			if ((Object)(object)boat != (Object)null)
			{
				return _fight.Contains(boat);
			}
			return false;
		}

		private static Boat DrivenBy(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			for (int i = 0; i < _fight.Count; i++)
			{
				Boat val = _fight[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					if ((Object)(object)val.Driver == (Object)(object)player)
					{
						return val;
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private static Boat NearPlayer(Player player)
		{
			return NearPlayer(player, 5.5f);
		}

		private static Boat NearPlayer(Player player, float radius)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			Vector3 zero = Vector3.zero;
			try
			{
				zero = ((!((Object)(object)player.Transform != (Object)null)) ? ((Component)player).transform.position : player.Transform.position);
			}
			catch
			{
				return null;
			}
			Boat result = null;
			float num = radius * radius;
			for (int i = 0; i < _fight.Count; i++)
			{
				Boat val = _fight[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Vector3 position = ((Component)val).transform.position;
				try
				{
					if ((Object)(object)val.VisualBoat != (Object)null)
					{
						position = val.VisualBoat.position;
					}
				}
				catch
				{
				}
				position.y = zero.y;
				Vector3 val2 = position - zero;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
					result = val;
				}
			}
			return result;
		}

		private static Player PlayerFromConn(NetworkConnection conn)
		{
			if (conn == (NetworkConnection)null || PlayerManager.Players == null)
			{
				return null;
			}
			foreach (Player player in PlayerManager.Players)
			{
				if ((Object)(object)player == (Object)null)
				{
					continue;
				}
				try
				{
					if (((NetworkBehaviour)player).Owner == conn)
					{
						return player;
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private static bool IsHost()
		{
			if ((Object)(object)Server.Instance != (Object)null)
			{
				return ((NetworkBehaviour)Server.Instance).IsServerInitialized;
			}
			return false;
		}

		[HarmonyPatch(typeof(BoatManager), "get_Boat")]
		[HarmonyPostfix]
		private static void PickBoat(ref Boat __result)
		{
			if ((Object)(object)_redirect != (Object)null)
			{
				__result = _redirect;
			}
			else if (IsRound)
			{
				Player player = (((Object)(object)_inputPlayer != (Object)null) ? _inputPlayer : Player.LocalPlayer);
				Boat val = DrivenBy(player) ?? NearPlayer(player);
				if ((Object)(object)val != (Object)null)
				{
					__result = val;
				}
			}
		}

		[HarmonyPatch(typeof(BoatManager), "SetBoat")]
		[HarmonyPrefix]
		private static bool KeepFightCols(Collider[] cols, Boat boat)
		{
			if (!IsRound && !IsFight(boat))
			{
				return true;
			}
			if (cols == null || (Object)(object)boat == (Object)null)
			{
				return true;
			}
			try
			{
				Dictionary<Collider, Boat> colToBoat = BoatManager.ColToBoat;
				for (int i = 0; i < cols.Length; i++)
				{
					if (!((Object)(object)cols[i] == (Object)null) && !colToBoat.ContainsKey(cols[i]))
					{
						colToBoat.Add(cols[i], boat);
					}
				}
			}
			catch
			{
			}
			return false;
		}

		[HarmonyPatch(typeof(BoatManager), "RemoveBoat")]
		[HarmonyPrefix]
		private static bool SkipClearAll()
		{
			if (!_wiping)
			{
				return !IsRound;
			}
			return true;
		}

		[HarmonyPatch(typeof(BoatInteractable), "Hover")]
		[HarmonyPrefix]
		private static void HoverUseThis(BoatInteractable __instance)
		{
			Boat val = (((Object)(object)__instance != (Object)null) ? ((Component)__instance).GetComponentInParent<Boat>() : null);
			if (!((Object)(object)val == (Object)null) && Keep(val))
			{
				try
				{
					val.UnlockBoat();
				}
				catch
				{
				}
				_redirect = val;
			}
		}

		[HarmonyPatch(typeof(BoatInteractable), "Hover")]
		[HarmonyPostfix]
		private static void HoverClear()
		{
			_redirect = null;
		}

		[HarmonyPatch(typeof(BoatInteractable), "Interact")]
		[HarmonyPrefix]
		private static bool DriveThis(BoatInteractable __instance, Player player)
		{
			if (!PvpSession.Queued)
			{
				return true;
			}
			if (!IsRound)
			{
				return false;
			}
			Boat val = (((Object)(object)__instance != (Object)null) ? ((Component)__instance).GetComponentInParent<Boat>() : null);
			if ((Object)(object)val == (Object)null)
			{
				val = NearPlayer(player);
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			try
			{
				val.UnlockBoat();
			}
			catch
			{
			}
			try
			{
				((Interactable)__instance).ToggleIsInteractable(true);
			}
			catch
			{
			}
			_redirect = val;
			try
			{
				Boat.ToggleWantToDrive(true);
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)Server.Instance != (Object)null)
				{
					Server.Instance.SetDriver(player);
				}
			}
			catch
			{
			}
			try
			{
				val.TrySetDriver(player);
			}
			catch
			{
			}
			_redirect = null;
			return false;
		}

		[HarmonyPatch(typeof(Server), "SendBoatInput")]
		[HarmonyPrefix]
		private static void LocalInputStart()
		{
			if (IsRound)
			{
				_inputPlayer = Player.LocalPlayer;
			}
		}

		[HarmonyPatch(typeof(Server), "SendBoatInput")]
		[HarmonyPostfix]
		private static void LocalInputEnd()
		{
			_inputPlayer = null;
		}

		[HarmonyPatch(typeof(Server), "RpcReader___SendBoatInput___1949707525")]
		[HarmonyPrefix]
		private static void NoteInputConn(NetworkConnection __2)
		{
			if (IsRound)
			{
				_inputPlayer = PlayerFromConn(__2);
			}
		}

		[HarmonyPatch(typeof(Server), "RpcReader___SendBoatInput___1949707525")]
		[HarmonyPostfix]
		private static void ClearInputConn()
		{
			_inputPlayer = null;
		}

		[HarmonyPatch(typeof(Server), "RpcReader___SetDriver___3849956746")]
		[HarmonyPrefix]
		private static void NoteDriverConn(NetworkConnection __2)
		{
			if (IsRound)
			{
				_inputPlayer = PlayerFromConn(__2);
			}
		}

		[HarmonyPatch(typeof(Server), "RpcReader___SetDriver___3849956746")]
		[HarmonyPostfix]
		private static void ClearDriverConn()
		{
			_inputPlayer = null;
		}
	}
	internal sealed class PvpBoomMark : MonoBehaviour
	{
		private float _nextPaint;

		private void LateUpdate()
		{
			if (!(Time.unscaledTime < _nextPaint))
			{
				_nextPaint = Time.unscaledTime + 0.35f;
				PvpBoom.StampMarks();
				PvpBoom.DressGun(((Component)this).GetComponent<Item>());
			}
		}
	}
	[HarmonyPatch]
	internal static class PvpBoom
	{
		private static Item _pistolPrefab;

		private static Item _dynamitePrefab;

		private static readonly Dictionary<ulong, string> LastBoom = new Dictionary<ulong, string>();

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

		private static Vector3 _lastPos;

		private static float _lastAt;

		private static int _seq;

		private static float _nextStamp;

		internal unsafe static void DropFromSky()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHost())
			{
				return;
			}
			Server instance = Server.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Item val = PistolPrefab();
			if ((Object)(object)val == (Object)null)
			{
				Debug.Log((object)"[HowToFishPvp] boom pistol: no pistol prefab");
				return;
			}
			Player localPlayer = Player.LocalPlayer;
			Vector3 val2 = Vector3.zero;
			if ((Object)(object)localPlayer != (Object)null)
			{
				try
				{
					val2 = (((Object)(object)localPlayer.Transform != (Object)null) ? localPlayer.Transform.position : ((Component)localPlayer).transform.position);
				}
				catch
				{
					val2 = ((Component)localPlayer).transform.position;
				}
			}
			if (!(((Vector3)(ref val2)).sqrMagnitude < 0.01f))
			{
				Vector3 val3 = val2 + Vector3.up * Random.Range(11f, 16f);
				Quaternion val4 = Quaternion.Euler(Random.Range(0f, 360f), Random.Range(0f, 360f), Random.Range(0f, 360f));
				Item val5 = Object.Instantiate<Item>(val, val3, val4);
				if (!((Object)(object)val5 == (Object)null))
				{
					((Component)val5).transform.SetParent((Transform)null, true);
					((Component)val5).transform.position = val3;
					((NetworkBehaviour)instance).Spawn(((Component)val5).gameObject, (NetworkConnection)null, default(Scene));
					((Component)val5).transform.position = val3;
					RegisterSpawned(val5);
					((Component)val5).gameObject.AddComponent<SlowDrop>().HoldPos = val3;
					KickDown(val5);
					Debug.Log((object)("[HowToFishPvp] dropped boom pistol at " + ((object)(*(Vector3*)(&val3))/*cast due to .constrained prefix*/).ToString()));
				}
			}
		}

		internal static Item PistolPrefab()
		{
			if ((Object)(object)_pistolPrefab != (Object)null)
			{
				return _pistolPrefab;
			}
			_pistolPrefab = FindPrefab("pistol", gun: true);
			return _pistolPrefab;
		}

		internal static void RegisterSpawned(Item spawned)
		{
			if (!((Object)(object)spawned == (Object)null))
			{
				if ((Object)(object)((Component)spawned).GetComponent<PvpBoomMark>() == (Object)null)
				{
					((Component)spawned).gameObject.AddComponent<PvpBoomMark>();
				}
				DressGun(spawned);
				int num = IdOf(spawned);
				if (num != 0)
				{
					KnownIds.Add(num);
					PvpSync.Send("boomgun " + num);
				}
				PlayMythicCatch();
				PvpSync.Send("mythic");
			}
		}

		internal static void HearGunId(int id)
		{
			if (id != 0)
			{
				KnownIds.Add(id);
				StampMarks();
			}
		}

		internal static void StampMarks()
		{
			if (KnownIds.Count == 0 || Time.unscaledTime < _nextStamp)
			{
				return;
			}
			_nextStamp = Time.unscaledTime + 0.25f;
			try
			{
				Dictionary<Transform, Item> items = ItemManager.Items;
				if (items == null)
				{
					return;
				}
				foreach (KeyValuePair<Transform, Item> item in items)
				{
					Item value = item.Value;
					if (!((Object)(object)value == (Object)null))
					{
						int num = IdOf(value);
						if (num != 0 && KnownIds.Contains(num) && (Object)(object)((Component)value).GetComponent<PvpBoomMark>() == (Object)null)
						{
							((Component)value).gameObject.AddComponent<PvpBoomMark>();
						}
					}
				}
			}
			catch
			{
			}
		}

		internal static void PlayMythicCatch()
		{
			try
			{
				AudioManager.PlayRandomGlobalClip("ShinyCreatureCaught_0", 1, 3, false, 0.5f, 0.1f);
			}
			catch
			{
			}
		}

		internal static void HearFrom(ulong steam, string data)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (IsHost() && !string.IsNullOrEmpty(data) && (!LastBoom.TryGetValue(steam, out var value) || !(value == data)))
			{
				LastBoom[steam] = data;
				if (ParsePos(data, out var pos))
				{
					ExplodeAt(pos, PlayerBySteam(steam));
				}
			}
		}

		internal static void DressGun(Item item)
		{
			if ((Object)(object)item == (Object)null || !IsHost())
			{
				return;
			}
			int num = BoomSkinIndex(item);
			if (num >= 0)
			{
				try
				{
					if (item.CurSkin != (byte)num)
					{
						item.ServerSetSkin((byte)num);
					}
				}
				catch
				{
				}
			}
			EquipRedDot(item);
		}

		internal static void SetMemberBoom(Vector3 pos)
		{
			_seq++;
			PvpSync.SetMemberBoom(pos.x.ToString("F2", CultureInfo.InvariantCulture) + " " + pos.y.ToString("F2", CultureInfo.InvariantCulture) + " " + pos.z.ToString("F2", CultureInfo.InvariantCulture) + " " + _seq);
		}

		private static void Request(Vector3 pos, Player shooter)
		{
			//IL_000f: 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)
			if (IsHost())
			{
				ExplodeAt(pos, shooter);
			}
			else
			{
				SetMemberBoom(pos);
			}
		}

		private static void ExplodeAt(Vector3 pos, Player shooter)
		{
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHost())
			{
				return;
			}
			if (Time.time - _lastAt < 0.18f)
			{
				Vector3 val = pos - _lastPos;
				if (((Vector3)(ref val)).sqrMagnitude < 6.25f)
				{
					return;
				}
			}
			_lastAt = Time.time;
			_lastPos = pos;
			Server instance = Server.Instance;
			Item val2 = DynamitePrefab();
			if ((Object)(object)instance == (Object)null || (Object)(object)val2 == (Object)null)
			{
				return;
			}
			Item val3 = Object.Instantiate<Item>(val2, pos, Quaternion.identity);
			if ((Object)(object)val3 == (Object)null)
			{
				return;
			}
			((Component)val3).transform.SetParent((Transform)null, true);
			((Component)val3).transform.position = pos;
			((Component)val3).transform.localScale = Vector3.one * 0.01f;
			HideVisual(val3);
			try
			{
				AccessTools.Field(typeof(Item), "<LastPlayer>k__BackingField").SetValue(val3, shooter);
			}
			catch
			{
			}
			Explosive val4 = (Explosive)(object)((val3 is Explosive) ? val3 : null);
			if ((Object)(object)val4 == (Object)null)
			{
				val4 = val3.Explosive;
			}
			if ((Object)(object)val4 != (Object)null)
			{
				try
				{
					AccessTools.Field(typeof(Explosive), "<PlayerWhoForcedExplosion>k__BackingField").SetValue(val4, shooter);
				}
				catch
				{
				}
			}
			((NetworkBehaviour)instance).Spawn(((Component)val3).gameObject, (NetworkConnection)null, default(Scene));
			((Component)val3).transform.position = pos;
			ExplosionInfo explosionInfo = val3.GetExplosionInfo();
			if (explosionInfo == null && (Object)(object)val4 != (Object)null)
			{
				explosionInfo = ((Item)val4).GetExplosionInfo();
			}
			if (explosionInfo != null)
			{
				ExplosionManager.ServerExplode(val3, explosionInfo);
			}
		}

		private static bool IsBoom(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)item).GetComponent<PvpBoomMark>() != (Object)null)
			{
				return true;
			}
			int num = IdOf(item);
			if (num != 0 && KnownIds.Contains(num))
			{
				return true;
			}
			Weapon val = (Weapon)(object)((item is Weapon) ? item : null);
			if ((Object)(object)val == (Object)null)
			{
				val = item.Weapon;
			}
			if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).GetComponent<PvpBoomMark>() != (Object)null)
			{
				return true;
			}
			if (IsPistol(item))
			{
				return HasBoomSkin(item);
			}
			return false;
		}

		private static bool OwnerHoldingBoom(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			try
			{
				if ((Object)(object)player.Holding != (Object)null && IsBoom(player.Holding.HeldItem))
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				Dictionary<Transform, Item> items = ItemManager.Items;
				if (items != null)
				{
					foreach (KeyValuePair<Transform, Item> item in items)
					{
						Item value = item.Value;
						if (!((Object)(object)value == (Object)null) && IsBoom(value) && (Object)(object)value.Holder == (Object)(object)player)
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool IsPistol(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			string text = NameOf(item);
			if (text.IndexOf("pistol") < 0)
			{
				return false;
			}
			if (text.IndexOf("packed") >= 0 || text.IndexOf("backup") >= 0)
			{
				return false;
			}
			return true;
		}

		private static bool HasBoomSkin(Item item)
		{
			//IL_0043: 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)
			if ((Object)(object)item == (Object)null || (Object)(object)item.SkinPreset == (Object)null)
			{
				return false;
			}
			try
			{
				IReadOnlyList<ItemSkin> skins = item.SkinPreset.Skins;
				int curSkin = item.CurSkin;
				if (skins == null || curSkin < 0 || curSkin >= skins.Count)
				{
					return false;
				}
				ItemSkin val = skins[curSkin];
				return SkinScore(((ItemSkin)(ref val)).Name) >= 80;
			}
			catch
			{
				return false;
			}
		}

		private static int BoomSkinIndex(Item item)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null || (Object)(object)item.SkinPreset == (Object)null)
			{
				return -1;
			}
			IReadOnlyList<ItemSkin> skins = item.SkinPreset.Skins;
			if (skins == null || skins.Count == 0)
			{
				return -1;
			}
			int result = -1;
			int num = -1;
			for (int i = 0; i < skins.Count; i++)
			{
				ItemSkin val = skins[i];
				int num2 = SkinScore(((ItemSkin)(ref val)).Name);
				if (num2 > num)
				{
					num = num2;
					result = i;
				}
			}
			if (num > 0)
			{
				return result;
			}
			return skins.Count - 1;
		}

		private static int SkinScore(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return 0;
			}
			string text = name.ToLowerInvariant().Trim();
			if (text.IndexOf("ruby") >= 0)
			{
				return 100;
			}
			if (text.IndexOf("crimson") >= 0 || text.IndexOf("scarlet") >= 0)
			{
				return 90;
			}
			if (text == "red")
			{
				return 85;
			}
			if (text.IndexOf("redwood") >= 0)
			{
				return 70;
			}
			if (text.StartsWith("red") && text.IndexOf("dot") < 0)
			{
				return 80;
			}
			if (text.IndexOf("gold") >= 0)
			{
				return 10;
			}
			return 0;
		}

		private static void EquipRedDot(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			try
			{
				Weapon val = (Weapon)(object)((item is Weapon) ? item : null);
				if ((Object)(object)val == (Object)null)
				{
					val = item.Weapon;
				}
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)item).GetComponentInChildren<Weapon>(true);
				}
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				Attachments attachments = val.Attachments;
				if ((Object)(object)attachments == (Object)null || !(AccessTools.Field(typeof(Attachments), "_sights").GetValue(attachments) is IList { Count: not 0 } list))
				{
					return;
				}
				int num = -1;
				int num2 = -1;
				for (int i = 0; i < list.Count; i++)
				{
					object? obj = list[i];
					Sight val2 = (Sight)((obj is Sight) ? obj : null);
					if (!((Object)(object)val2 == (Object)null))
					{
						int num3 = 0;
						if (val2 is RedDotSight)
						{
							num3 = 100;
						}
						string text = ((Object)val2).name.ToLowerInvariant();
						string text2 = InfoName(((Attachment)val2).Info);
						if (text.IndexOf("reddot") >= 0 || text.IndexOf("red dot") >= 0 || text2.IndexOf("reddot") >= 0 || text2.IndexOf("red dot") >= 0)
						{
							num3 = Math.Max(num3, 90);
						}
						if (text.IndexOf("rds") >= 0 || text2.IndexOf("rds") >= 0)
						{
							num3 = Math.Max(num3, 80);
						}
						if (num3 > num2)
						{
							num2 = num3;
							num = i;
						}
					}
				}
				if (num < 0)
				{
					return;
				}
				object? obj2 = list[num];
				Sight val3 = (Sight)((obj2 is Sight) ? obj2 : null);
				if ((Object)(object)val3 != (Object)null && (Object)(object)((Attachment)val3).Info != (Object)null)
				{
					try
					{
						if (!attachments.HasAttachment(((Attachment)val3).Info))
						{
							attachments.SetAttachment(((Attachment)val3).Info);
						}
						return;
					}
					catch
					{
						attachments._syncedSight.Value = (byte)num;
						return;
					}
				}
				attachments._syncedSight.Value = (byte)num;
			}
			catch
			{
			}
		}

		private static string InfoName(AttachmentInfo info)
		{
			if ((Object)(object)info == (Object)null)
			{
				return "";
			}
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(AttachmentInfo), "_name");
				if (fieldInfo != null)
				{
					string text = fieldInfo.GetValue(info) as string;
					if (!string.IsNullOrEmpty(text))
					{
						return text.ToLowerInvariant();
					}
				}
			}
			catch
			{
			}
			try
			{
				string nameLocalized = info.NameLocalized;
				if (!string.IsNullOrEmpty(nameLocalized))
				{
					return nameLocalized.ToLowerInvariant();
				}
			}
			catch
			{
			}
			return ((Object)info).name.ToLowerInvariant();
		}

		private static Item DynamitePrefab()
		{
			if ((Object)(object)_dynamitePrefab != (Object)null)
			{
				return _dynamitePrefab;
			}
			_dynamitePrefab = FindPrefab("dynamite", gun: false);
			return _dynamitePrefab;
		}

		private static Item FindPrefab(string key, bool gun)
		{
			Item result = null;
			int num = int.MinValue;
			foreach (Item item in AllItems())
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				string text = NameOf(item);
				if (text.IndexOf(key) >= 0 && text.IndexOf("packed") < 0 && text.IndexOf("backup") < 0 && text.IndexOf("attachment") < 0 && (!gun || !((Object)(object)item.Weapon == (Object)null) || item is Weapon) && (gun || item.GetExplosionInfo() != null || !((Object)(object)item.Explosive == (Object)null) || item is Explosive))
				{
					int num2 = 40 - text.Length;
					if (text == key)
					{
						num2 += 80;
					}
					if (num2 > num)
					{
						num = num2;
						result = item;
					}
				}
			}
			return result;
		}

		private static List<Item> AllItems()
		{
			List<Item> list = new List<Item>();
			HashSet<int> hashSet = new HashSet<int>();
			try
			{
				if (AccessTools.Field(typeof(GameInfo), "_nameToSpawnable").GetValue(null) is Dictionary<string, Item> dictionary)
				{
					foreach (KeyValuePair<string, Item> item in dictionary)
					{
						if (!((Object)(object)item.Value == (Object)null) && hashSet.Add(((Object)item.Value).GetInstanceID()))
						{
							list.Add(item.Value);
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				if (AccessTools.Field(typeof(GameInfo), "_allItems").GetValue(null) is Dictionary<byte, Item> dictionary2)
				{
					foreach (KeyValuePair<byte, Item> item2 in dictionary2)
					{
						if (!((Object)(object)item2.Value == (Object)null) && hashSet.Add(((Object)item2.Value).GetInstanceID()))
						{
							list.Add(item2.Value);
						}
					}
				}
			}
			catch
			{
			}
			Item[] array = null;
			try
			{
				array = Resources.LoadAll<Item>("Items");
			}
			catch
			{
			}
			if (array != null)
			{
				for (int i = 0; i < array.Length; i++)
				{
					if (!((Object)(object)array[i] == (Object)null) && hashSet.Add(((Object)array[i]).GetInstanceID()))
					{
						list.Add(array[i]);
					}
				}
			}
			return list;
		}

		private static string NameOf(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return "";
			}
			return ((Object)item).name.Replace(" ", "").ToLowerInvariant();
		}

		private static void HideVisual(Item item)
		{
			try
			{
				Renderer[] componentsInChildren = ((Component)item).GetComponentsInChildren<Renderer>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].enabled = false;
				}
			}
			catch
			{
			}
		}

		private static void KickDown(Item spawned)
		{
			//IL_0060: 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)
			try
			{
				if ((Object)(object)spawned.RigidbodySync != (Object)null)
				{
					spawned.RigidbodySync.SetKinematic(false);
				}
				Rigidbody rig = spawned.Rig;
				if (!((Object)(object)rig == (Object)null))
				{
					rig.isKinematic = false;
					rig.useGravity = true;
					rig.linearDamping = 0.8f;
					rig.angularDamping = 0.9f;
					rig.linearVelocity = new Vector3(0f, -3.4f, 0f);
					rig.angularVelocity = Random.insideUnitSphere * 1.4f;
				}
			}
			catch
			{
			}
		}

		private static bool ParsePos(string data, out Vector3 pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			pos = Vector3.zero;
			if (string.IsNullOrEmpty(data))
			{
				return false;
			}
			string[] array = data.Split(new char[1] { ' ' });
			if (array.Length < 3)
			{
				return false;
			}
			if (!float.TryParse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			if (!float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				return false;
			}
			if (!float.TryParse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
			{
				return false;
			}
			pos = new Vector3(result, result2, result3);
			return true;
		}

		private static Player PlayerBySteam(ulong steam)
		{
			if (steam == 0L)
			{
				return null;
			}
			Player[] array = Object.FindObjectsOfType<Player>(true);
			foreach (Player val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					if (val.SteamID == steam)
					{
						return val;
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private static bool IsHost()
		{
			if ((Object)(object)Server.Instance != (Object)null)
			{
				return ((NetworkBehaviour)Server.Instance).IsServerInitialized;
			}
			return false;
		}

		private static int IdOf(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return 0;
			}
			try
			{
				return ((NetworkBehaviour)item).ObjectId;
			}
			catch
			{
				return 0;
			}
		}

		private static Vector3 AimPoint(Player player)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			Transform val = null;
			try
			{
				if ((Object)(object)player != (Object)null)
				{
					val = player.CamObject;
				}
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				return Vector3.zero;
			}
			int num = -1;
			try
			{
				num = LayerMask.op_Implicit(GameInfo.ProjectileHitLayer);
			}
			catch
			{
			}
			RaycastHit val2 = default(RaycastHit);
			if (Physics.Raycast(val.position, val.forward, ref val2, 250f, num))
			{
				return ((RaycastHit)(ref val2)).point;
			}
			return val.position + val.forward * 80f;
		}

		[HarmonyPatch(typeof(ProjectileManager), "Hit")]
		[HarmonyPostfix]
		private static void AfterHit(Projectile __0, RaycastHit __2)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (__0 != null && OwnerHoldingBoom(__0.Owner))
			{
				Request(((RaycastHit)(ref __2)).point, __0.Owner);
			}
		}

		[HarmonyPatch(typeof(ProjectileManager), "HitWater")]
		[HarmonyPostfix]
		private static void AfterWater(Projectile __0)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (__0 != null && OwnerHoldingBoom(__0.Owner))
			{
				Request(__0.Position, __0.Owner);
			}
		}

		[HarmonyPatch(typeof(Weapon), "Shoot")]
		[HarmonyPostfix]
		private static void AfterShoot(Weapon __instance)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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)
			if ((Object)(object)__instance == (Object)null || !IsBoom((Item)(object)__instance))
			{
				return;
			}
			Player val = null;
			try
			{
				val = ((Item)__instance).Holder;
			}
			catch
			{
			}
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val != (Object)(object)Player.LocalPlayer))
			{
				Vector3 pos = AimPoint(val);
				if (!(((Vector3)(ref pos)).sqrMagnitude < 0.01f))
				{
					Request(pos, val);
				}
			}
		}

		[HarmonyPatch(typeof(Weapon), "OnPickUp")]
		[HarmonyPostfix]
		private static void AfterPick(Weapon __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				int num = IdOf((Item)(object)__instance);
				if (num != 0 && KnownIds.Contains(num) && (Object)(object)((Component)__instance).GetComponent<PvpBoomMark>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<PvpBoomMark>();
				}
				if ((Object)(object)((Component)__instance).GetComponent<PvpBoomMark>() != (Object)null || IsBoom((Item)(object)__instance))
				{
					DressGun((Item)(object)__instance);
				}
			}
		}
	}
	internal sealed class PvpCloakMark : MonoBehaviour
	{
		private float _nextPaint;

		private void LateUpdate()
		{
			if (!(Time.unscaledTime < _nextPaint))
			{
				_nextPaint = Time.unscaledTime + 0.35f;
				PvpCloak.StampMarks();
				PvpCloak.DressGun(((Component)this).GetComponent<Item>());
			}
		}
	}
	[HarmonyPatch]
	internal static class PvpCloak
	{
		private static Item _knifePrefab;

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

		private static readonly HashSet<ulong> Cloaked = new HashSet<ulong>();

		private static readonly Dictionary<Renderer, bool> SavedRend = new Dictionary<Renderer, bool>();

		private static readonly HashSet<Renderer> HiddenRend = new HashSet<Renderer>();

		private static readonly Dictionary<GameObject, bool> SavedGo = new Dictionary<GameObject, bool>();

		private static readonly HashSet<GameObject> HiddenGo = new HashSet<GameObject>();

		private static float _nextStamp;

		private static float _nextWrite;

		private static bool _localUsed;

		private static bool _lastWriteOn;

		private static bool _wroteOnce;

		private static bool _loggedSkins;

		internal unsafe static void DropFromSky()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHost())
			{
				return;
			}
			Server instance = Server.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Item val = KnifePrefab();
			if ((Object)(object)val == (Object)null)
			{
				Debug.Log((object)"[HowToFishPvp] cloak knife: no knife prefab");
				return;
			}
			Player localPlayer = Player.LocalPlayer;
			Vector3 val2 = Vector3.zero;
			if ((Object)(object)localPlayer != (Object)null)
			{
				try
				{
					val2 = (((Object)(object)localPlayer.Transform != (Object)null) ? localPlayer.Transform.position : ((Component)localPlayer).transform.position);
				}
				catch
				{
					val2 = ((Component)localPlayer).transform.position;
				}
			}
			if (!(((Vector3)(ref val2)).sqrMagnitude < 0.01f))
			{
				Vector3 val3 = val2 + Vector3.up * Random.Range(11f, 16f);
				Quaternion val4 = Quaternion.Euler(Random.Range(0f, 360f), Random.Range(0f, 360f), Random.Range(0f, 360f));
				Item val5 = Object.Instantiate<Item>(val, val3, val4);
				if (!((Object)(object)val5 == (Object)null))
				{
					((Component)val5).transform.SetParent((Transform)null, true);
					((Component)val5).transform.position = val3;
					((NetworkBehaviour)instance).Spawn(((Component)val5).gameObject, (NetworkConnection)null, default(Scene));
					((Component)val5).transform.position = val3;
					RegisterSpawned(val5);
					((Component)val5).gameObject.AddComponent<SlowDrop>().HoldPos = val3;
					KickDown(val5);
					Debug.Log((object)("[HowToFishPvp] dropped cloak knife at " + ((object)(*(Vector3*)(&val3))/*cast due to .constrained prefix*/).ToString()));
				}
			}
		}

		internal static Item KnifePrefab()
		{
			if ((Object)(object)_knifePrefab != (Object)null)
			{
				return _knifePrefab;
			}
			Item val = null;
			int num = int.MinValue;
			foreach (Item item in AllItems())
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				string text = NameOf(item);
				if (text.IndexOf("packed") < 0 && text.IndexOf("backup") < 0 && text.IndexOf("attachment") < 0 && text.IndexOf("knife") >= 0 && (!((Object)(object)item.Melee == (Object)null) || item is Melee))
				{
					int num2 = 80 - text.Length;
					if (text == "knife")
					{
						num2 += 80;
					}
					if (num2 > num)
					{
						num = num2;
						val = item;
					}
				}
			}
			_knifePrefab = val;
			if ((Object)(object)val != (Object)null)
			{
				Debug.Log((object)("[HowToFishPvp] cloak knife prefab=" + ((Object)val).name));
			}
			return _knifePrefab;
		}

		internal static void RegisterSpawned(Item spawned)
		{
			if (!((Object)(object)spawned == (Object)null))
			{
				if ((Object)(object)((Component)spawned).GetComponent<PvpCloakMark>() == (Object)null)
				{
					((Component)spawned).gameObject.AddComponent<PvpCloakMark>();
				}
				DressGun(spawned);
				int num = IdOf(spawned);
				if (num != 0)
				{
					KnownIds.Add(num);
					PvpSync.Send("knifegun " + num);
				}
				PvpBoom.PlayMythicCatch();
				PvpSync.Send("mythic");
			}
		}

		internal static void HearGunId(int id)
		{
			if (id != 0)
			{
				KnownIds.Add(id);
				StampMarks();
			}
		}

		internal static void HearCloak(ulong steam, bool on)
		{
			if (steam != 0L)
			{
				if (on)
				{
					Cloaked.Add(steam);
				}
				else
				{
					Cloaked.Remove(steam);
				}
			}
		}

		internal static void StampMarks()
		{
			if (KnownIds.Count == 0 || Time.unscaledTime < _nextStamp)
			{
				return;
			}
			_nextStamp = Time.unscaledTime + 0.25f;
			try
			{
				Dictionary<Transform, Item> items = ItemManager.Items;
				if (items == null)
				{
					return;
				}
				foreach (KeyValuePair<Transform, Item> item in items)
				{
					Item value = item.Value;
					if (!((Object)(object)value == (Object)null))
					{
						int num = IdOf(value);
						if (num != 0 && KnownIds.Contains(num) && (Object)(object)((Component)value).GetComponent<PvpCloakMark>() == (Object)null)
						{
							((Component)value).gameObject.AddComponent<PvpCloakMark>();
						}
					}
				}
			}
			catch
			{
			}
		}

		internal static void DressGun(Item item)
		{
			if ((Object)(object)item == (Object)null || !IsHost())
			{
				return;
			}
			int num = CoolSkinIndex(item);
			if (num < 0)
			{
				return;
			}
			try
			{
				if (item.CurSkin != (byte)num)
				{
					item.ServerSetSkin((byte)num);
				}
			}
			catch
			{
			}
		}

		internal static void Tick()
		{
			if (!PvpSession.Queued)
			{
				if (Cloaked.Count > 0 || HiddenRend.Count > 0)
				{
					Cloaked.Clear();
					ShowAll();
				}
			}
			else
			{
				TickLocal();
				PvpSync.PollCloaks();
				ApplyGhosts();
				StampMarks();
			}
		}

		internal static void ClearRound()
		{
			Cloaked.Clear();
			ShowAll();
		}

		internal static void LateTick()
		{
			if (PvpSession.Queued)
			{
				ApplyGhosts();
			}
		}

		internal static void Reveal(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				if ((Object)(object)player == (Object)(object)Player.LocalPlayer)
				{
					_localUsed = true;
				}
				ulong num = SteamOf(player);
				if (num != 0L)
				{
					Cloaked.Remove(num);
				}
				if ((Object)(object)player == (Object)(object)Player.LocalPlayer)
				{
					WriteCloak(on: false, force: true);
				}
			}
		}

		private static void TickLocal()
		{
			Player localPlayer = Player.LocalPlayer;
			int num;
			if ((Object)(object)localPlayer != (Object)null)
			{
				num = (HoldingCloak(localPlayer) ? 1 : 0);
				if (num != 0)
				{
					goto IL_0021;
				}
			}
			else
			{
				num = 0;
			}
			_localUsed = false;
			goto IL_0021;
			IL_0021:
			if (num != 0 && KnifeAttacking(localPlayer))
			{
				_localUsed = true;
			}
			if (num != 0 && (Input.GetMouseButtonDown(0) || Input.GetMouseButton(0)))
			{
				_localUsed = true;
			}
			bool flag = num != 0 && !_localUsed;
			ulong num2 = SteamOf(localPlayer);
			if (num2 != 0L)
			{
				if (flag)
				{
					Cloaked.Add(num2);
				}
				else
				{
					Cloaked.Remove(num2);
				}
			}
			WriteCloak(flag, force: false);
		}

		private static void WriteCloak(bool on, bool force)
		{
			if (!force && _wroteOnce && on == _lastWriteOn && Time.unscaledTime < _nextWrite)
			{
				return;
			}
			_nextWrite = Time.unscaledTime + 0.8f;
			_lastWriteOn = on;
			_wroteOnce = true;
			PvpSync.SetMemberCloak(on ? "1" : "0");
			if (IsHost())
			{
				ulong num = SteamOf(Player.LocalPlayer);
				if (num != 0L)
				{
					PvpSync.Send("cloak " + num + " " + (on ? "1" : "0"));
				}
			}
		}

		private static void ApplyGhosts()
		{
			Player[] array = null;
			try
			{
				array = Object.FindObjectsOfType<Player>(true);
			}
			catch
			{
				return;
			}
			if (array == null)
			{
				return;
			}
			Player localPlayer = Player.LocalPlayer;
			HashSet<Renderer> keepR = new HashSet<Renderer>();
			HashSet<GameObject> keepG = new HashSet<GameObject>();
			foreach (Player val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)localPlayer))
				{
					bool hide = ShouldHide(val);
					SetGhost(val, hide, keepR, keepG);
				}
			}
			RestoreUnused(keepR, keepG);
		}

		private static bool ShouldHide(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			try
			{
				if ((Object)(object)player.Dying != (Object)null && player.Dying.IsDead)
				{
					return false;
				}
			}
			catch
			{
			}
			ulong num = SteamOf(player);
			if (num != 0L)
			{
				return Cloaked.Contains(num);
			}
			return false;
		}

		private static void SetGhost(Player player, bool hide, HashSet<Renderer> keepR, HashSet<GameObject> keepG)
		{
			if (!hide)
			{
				return;
			}
			HideRoot(OtherRoot(player), keepR);
			HideRoot(player.Transform, keepR);
			try
			{
				if ((Object)(object)player.Body != (Object)null)
				{
					HideRoot(((Component)player.Body).transform, keepR);
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)player.Arms != (Object)null)
				{
					HideRoot(((Component)player.Arms).transform, keepR);
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)player.Hands != (Object)null)
				{
					HideRoot(((Component)player.Hands).transform, keepR);
					player.Hands.ToggleHandMeshes(false);
					object? value = AccessTools.Field(typeof(PlayerHands), "_handModelLeft").GetValue(player.Hands);
					HideRenderer((Renderer)((value is Renderer) ? value : null), keepR);
					object? value2 = AccessTools.Field(typeof(PlayerHands), "_handModelRight").GetValue(player.Hands);
					HideRenderer((Renderer)((value2 is Renderer) ? value2 : null), keepR);
				}
			}
			catch
			{
			}
			try
			{
				if (AccessTools.Field(typeof(Player), "_otherObjects").GetValue(player) is List<GameObject> list)
				{
					for (int i = 0; i < list.Count; i++)
					{
						if ((Object)(object)list[i] != (Object)null)
						{
							HideRoot(list[i].transform, keepR);
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)player.Other != (Object)null)
				{
					object? value3 = AccessTools.Field(typeof(OtherPlayer), "_otherPlayerCanvasHolder").GetValue(player.Other);
					Transform val = (Transform)((value3 is Transform) ? value3 : null);
					HideGo(((Object)(object)val != (Object)null) ? ((Component)val).gameObject : null, keepG);
					object? value4 = AccessTools.Field(typeof(OtherPlayer), "_nameText").GetValue(player.Other);
					Component val2 = (Component)((value4 is Component) ? value4 : null);
					if ((Object)(object)val2 != (Object)null)
					{
						HideGo(val2.gameObject, keepG);
					}
				}
			}
			catch
			{
			}
			HideHeld(player, keepR);
		}

		private static Transform OtherRoot(Player player)
		{
			try
			{
				if ((Object)(object)player.Other != (Object)null && (Object)(object)player.Other.Transform != (Object)null)
				{
					return player.Other.Transform;
				}
			}
			catch
			{
			}
			return null;
		}

		private static void HideHeld(Player player, HashSet<Renderer> keepR)
		{
			HideItemHands(((Object)(object)player.Holding != (Object)null) ? player.Holding.HeldItem : null, keepR);
			try
			{
				Dictionary<Transform, Item> items = ItemManager.Items;
				if (items == null)
				{
					return;
				}
				foreach (KeyValuePair<Transform, Item> item in items)
				{
					Item value = item.Value;
					if (!((Object)(object)value == (Object)null) && !((Object)(object)value.Holder != (Object)(object)player))
					{
						HideItemHands(value, keepR);
					}
				}
			}
			catch
			{
			}
		}

		private static void HideItemHands(Item item, HashSet<Renderer> keepR)
		{
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			HideRoot(((Component)item).transform, keepR);
			try
			{
				if ((Object)(object)item.HandModelRight != (Object)null)
				{
					HideRoot(item.HandModelRight, keepR);
				}
				if ((Object)(object)item.HandModelLeft != (Object)null)
				{
					HideRoot(item.HandModelLeft, keepR);
				}
			}
			catch
			{
			}
			try
			{
				Tool val = item.Tool;
				if ((Object)(object)val == (Object)null)
				{
					val = (Tool)(object)((item is Tool) ? item : null);
				}
				if ((Object)(object)val != (Object)null && (Object)(object)val.HandsMesh != (Object)null)
				{
					HideRenderer(val.HandsMesh, keepR);
				}
			}
			catch
			{
			}
		}

		private static void HideRenderer(Renderer r, HashSet<Renderer> keep)
		{
			if (!((Object)(object)r == (Object)null))
			{
				keep.Add(r);
				if (!HiddenRend.Contains(r))
				{
					SavedRend[r] = r.enabled;
					HiddenRend.Add(r);
				}
				r.enabled = false;
			}
		}

		private static void HideRoot(Transform root, HashSet<Renderer> keep)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				keep.Add(val);
				if (HiddenRend.Contains(val))
				{
					if (val.enabled)
					{
						val.enabled = false;
					}
				}
				else
				{
					SavedRend[val] = val.enabled;
					HiddenRend.Add(val);
					val.enabled = false;
				}
			}
		}

		private static void HideGo(GameObject go, HashSet<GameObject> keep)
		{
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			keep.Add(go);
			if (HiddenGo.Contains(go))
			{
				if (go.activeSelf)
				{
					go.SetActive(false);
				}
				return;
			}
			SavedGo[go] = go.activeSelf;
			HiddenGo.Add(go);
			if (go.activeSelf)
			{
				go.SetActive(false);
			}
		}

		private static void RestoreUnused(HashSet<Renderer> keepR, HashSet<GameObject> keepG)
		{
			if (HiddenRend.Count > 0)
			{
				List<Renderer> list = new List<Renderer>();
				foreach (Renderer item in HiddenRend)
				{
					if (!((Object)(object)item != (Object)null) || !keepR.Contains(item))
					{
						list.Add(item);
					}
				}
				for (int i = 0; i < list.Count; i++)
				{
					Renderer val = list[i];
					HiddenRend.Remove(val);
					bool value = true;
					if ((Object)(object)val != (Object)null)
					{
						SavedRend.TryGetValue(val, out value);
					}
					SavedRend.Remove(val);
					if ((Object)(object)val != (Object)null)
					{
						val.enabled = value;
					}
				}
			}
			if (HiddenGo.Count <= 0)
			{
				return;
			}
			List<GameObject> list2 = new List<GameObject>();
			foreach (GameObject item2 in HiddenGo)
			{
				if (!((Object)(object)item2 != (Object)null) || !keepG.Contains(item2))
				{
					list2.Add(item2);
				}
			}
			for (int j = 0; j < list2.Count; j++)
			{
				GameObject val2 = list2[j];
				HiddenGo.Remove(val2);
				bool value2 = true;
				if ((Object)(object)val2 != (Object)null)
				{
					SavedGo.TryGetValue(val2, out value2);
				}
				SavedGo.Remove(val2);
				if ((Object)(object)val2 != (Object)null)
				{
					val2.SetActive(value2);
				}
			}
		}

		private static void ShowAll()
		{
			foreach (KeyValuePair<Renderer, bool> item in SavedRend)
			{
				if ((Object)(object)item.Key != (Object)null)
				{
					item.Key.enabled = item.Value;
				}
			}
			foreach (KeyValuePair<GameObject, bool> item2 in SavedGo)
			{
				if ((Object)(object)item2.Key != (Object)null)
				{
					item2.Key.SetActive(item2.Value);
				}
			}
			SavedRend.Clear();
			HiddenRend.Clear();
			SavedGo.Clear();
			HiddenGo.Clear();
		}

		private static bool KnifeAttacking(Player player)
		{
			Item val = null;
			try
			{
				if ((Object)(object)player != (Object)null && (Object)(object)player.Holding != (Object)null)
				{
					val = player.Holding.HeldItem;
				}
			}
			catch
			{
			}
			Melee val2 = (Melee)(object)((val is Melee) ? val : null);
			if ((Object)(object)val2 == (Object)null && (Object)(object)val != (Object)null)
			{
				val2 = val.Melee;
			}
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			try
			{
				if ((bool)AccessTools.Field(typeof(Melee), "_queuedAttack").GetValue(val2))
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				if (AccessTools.Field(typeof(Melee), "_isAttacking").GetValue(val2) is bool[] array)
				{
					for (int i = 0; i < array.Length; i++)
					{
						if (array[i])
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				if (AccessTools.Field(typeof(Melee), "_isReturning").GetValue(val2) is bool[] array2)
				{
					for (int j = 0; j < array2.Length; j++)
					{
						if (array2[j])
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool HoldingCloak(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			try
			{
				if ((Object)(object)player.Holding != (Object)null && IsCloak(player.Holding.HeldItem))
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				Dictionary<Transform, Item> items = ItemManager.Items;
				if (items != null)
				{
					foreach (KeyValuePair<Transform, Item> item in items)
					{
						Item value = item.Value;
						if (!((Object)(object)value == (Object)null) && IsCloak(value) && (Object)(object)value.Holder == (Object)(object)player)
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool IsCloak(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)item).GetComponent<PvpCloakMark>() != (Object)null)
			{
				return true;
			}
			int num = IdOf(item);
			if (num != 0 && KnownIds.Contains(num))
			{
				return true;
			}
			if (IsKnife(item))
			{
				return HasCoolSkin(item);
			}
			return false;
		}

		private static bool IsKnife(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			string text = NameOf(item);
			if (text.IndexOf("knife") < 0)
			{
				return false;
			}
			if (text.IndexOf("packed") >= 0 || text.IndexOf("backup") >= 0)
			{
				return false;
			}
			return true;
		}

		private static bool HasCoolSkin(Item item)
		{
			//IL_0043: 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)
			if ((Object)(object)item == (Object)null || (Object)(object)item.SkinPreset == (Object)null)
			{
				return false;
			}
			try
			{
				IReadOnlyList<ItemSkin> skins = item.SkinPreset.Skins;
				int curSkin = item.CurSkin;
				if (skins == null || curSkin < 0 || curSkin >= skins.Count)
				{
					return false;
				}
				ItemSkin val = skins[curSkin];
				return SkinScore(((ItemSkin)(ref val)).Name) >= 80;
			}
			catch
			{
				return false;
			}
		}

		private static int CoolSkinIndex(Item item)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null || (Object)(object)item.SkinPreset == (Object)null)
			{
				return -1;
			}
			IReadOnlyList<ItemSkin> skins = item.SkinPreset.Skins;
			if (skins == null || skins.Count == 0)
			{
				return -1;
			}
			ItemSkin val;
			if (!_loggedSkins)
			{
				_loggedSkins = true;
				List<string> list = new List<string>();
				for (int i = 0; i < skins.Count; i++)
				{
					val = skins[i];
					list.Add(((ItemSkin)(ref val)).Name);
				}
				Debug.Log((object)("[HowToFishPvp] knife skins: " + string.Join(", ", list.ToArray())));
			}
			int result = -1;
			int num = -1;
			for (int j = 0; j < skins.Count; j++)
			{
				val = skins[j];
				int num2 = SkinScore(((ItemSkin)(ref val)).Name);
				if (num2 > num)
				{
					num = num2;
					result = j;
				}
			}
			if (num > 0)
			{
				return result;
			}
			return skins.Count - 1;
		}

		private static int SkinScore(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return 0;
			}
			string text = name.ToLowerInvariant().Trim();
			if (text.IndexOf("galaxy") >= 0)
			{
				return 100;
			}
			if (text.IndexOf("rainbow") >= 0)
			{
				return 92;
			}
			if (text.IndexOf("diamond") >= 0)
			{
				return 88;
			}
			if (text.IndexOf("blaze") >= 0)
			{
				return 80;
			}
			if (text.IndexOf("gold") >= 0)
			{
				return 70;
			}
			if (text.IndexOf("ruby") >= 0)
			{
				return 64;
			}
			if (text.IndexOf("tiger") >= 0)
			{
				return 50;
			}
			if (text.IndexOf("hazard") >= 0)
			{
				return 40;
			}
			return 0;
		}

		private static List<Item> AllItems()
		{
			List<Item> list = new List<Item>();
			HashSet<int> hashSet = new HashSet<int>();
			try
			{
				if (AccessTools.Field(typeof(GameInfo), "_nameToSpawnable").GetValue(null) is Dictionary<string, Item> dictionary)
				{
					foreach (KeyValuePair<string, Item> item in dictionary)
					{
						if (!((Object)(object)item.Value == (Object)null) && hashSet.Add(((Object)item.Value).GetInstanceID()))
						{
							list.Add(item.Value);
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Item[] array = Resources.LoadAll<Item>("Items");
				if (array != null)
				{
					for (int i = 0; i < array.Length; i++)
					{
						if (!((Object)(object)array[i] == (Object)null) && hashSet.Add(((Object)array[i]).GetInstanceID()))
						{
							list.Add(array[i]);
						}
					}
				}
			}
			catch
			{
			}
			return list;
		}

		private static string NameOf(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return "";
			}
			return ((Object)item).name.Replace(" ", "").ToLowerInvariant();
		}

		private static void KickDown(Item spawned)
		{
			//IL_0060: 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)
			try
			{
				if ((Object)(object)spawned.RigidbodySync != (Object)null)
				{
					spawned.RigidbodySync.SetKinematic(false);
				}
				Rigidbody rig = spawned.Rig;
				if (!((Object)(object)rig == (Object)null))
				{
					rig.isKinematic = false;
					rig.useGravity = true;
					rig.linearDamping = 0.8f;
					rig.angularDamping = 0.9f;
					rig.linearVelocity = new Vector3(0f, -3.4f, 0f);
					rig.angularVelocity = Random.insideUnitSphere * 1.4f;
				}
			}
			catch
			{
			}
		}

		private static ulong SteamOf(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return 0uL;
			}
			try
			{
				return player.SteamID;
			}
			catch
			{
				return 0uL;
			}
		}

		private static bool IsHost()
		{
			if ((Object)(object)Server.Instance != (Object)null)
			{
				return ((NetworkBehaviour)Server.Instance).IsServerInitialized;
			}
			return false;
		}

		private static int IdOf(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return 0;
			}
			try
			{
				return ((NetworkBehaviour)item).ObjectId;
			}
			catch
			{
				return 0;
			}
		}

		[HarmonyPatch(typeof(Melee), "StartAttacking")]
		[HarmonyPostfix]
		private static void AfterMelee(Melee __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				Player holder = ((Item)__instance).Holder;
				if (!((Object)(object)holder == (Object)null) && (IsCloak((Item)(object)__instance) || HoldingCloak(holder) || IsKnife((Item)(object)__instance)))
				{
					Reveal(holder);
				}
			}
		}

		[HarmonyPatch(typeof(Melee), "ObserverStartAttacking")]
		[HarmonyPostfix]
		private static void AfterMeleeObs(Melee __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				Player holder = ((Item)__instance).Holder;
				if (!((Object)(object)holder == (Object)null) && (IsCloak((Item)(object)__instance) || HoldingCloak(holder) || IsKnife((Item)(object)__instance)))
				{
					Reveal(holder);
				}
			}
		}

		[HarmonyPatch(typeof(Item), "OnPickUp")]
		[HarmonyPostfix]
		private static void AfterPick(Item __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				int num = IdOf(__instance);
				if (num != 0 && KnownIds.Contains(num) && (Object)(object)((Component)__instance).GetComponent<PvpCloakMark>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<PvpCloakMark>();
				}
				if ((Object)(object)((Component)__instance).GetComponent<PvpCloakMark>() != (Object)null || IsCloak(__instance))
				{
					DressGun(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Item), "OnDrop")]
		[HarmonyPostfix]
		private static void AfterDrop(Item __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && IsCloak(__instance) && (Object)(object)Player.LocalPlayer != (Object)null && (Object)(object)__instance.Holder == (Object)null)
			{
				_localUsed = false;
			}
		}

		[HarmonyPatch(typeof(Tool), "TryActivateAnimatedHands")]
		[HarmonyPostfix]
		private static void AfterToolHands(Tool __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			Player holder = ((Item)__instance).Holder;
			if ((Object)(object)holder == (Object)null || (Object)(object)holder == (Object)(object)Player.LocalPlayer || !ShouldHide(holder))
			{
				return;
			}
			try
			{
				if ((Object)(object)__instance.HandsMesh != (Object)null)
				{
					__instance.HandsMesh.enabled = false;
				}
			}
			catch
			{
			}
		}

		[HarmonyPatch(typeof(PlayerHands), "ToggleHandMeshes")]
		[HarmonyPostfix]
		private static void AfterToggleHands(PlayerHands __instance, bool enable)
		{
			if (!enable || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			object? value = AccessTools.Field(typeof(PlayerHands), "_player").GetValue(__instance);
			Player val = (Player)((value is Player) ? value : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)Player.LocalPlayer || !ShouldHide(val))
			{
				return;
			}
			try
			{
				object? value2 = AccessTools.Field(typeof(PlayerHands), "_handModelLeft").GetValue(__instance);
				Renderer val2 = (Renderer)((value2 is Renderer) ? value2 : null);
				object? value3 = AccessTools.Field(typeof(PlayerHands), "_handModelRight").GetValue(__instance);
				Renderer val3 = (Renderer)((value3 is Renderer) ? value3 : null);
				if ((Object)(object)val2 != (Object)null)
				{
					val2.enabled = false;
				}
				if ((Object)(object)val3 != (Object)null)
				{
					val3.enabled = false;
				}
			}
			catch
			{
			}
		}
	}
	internal sealed class PvpCloakDriver : MonoBehaviour
	{
		private void LateUpdate()
		{
			PvpCloak.LateTick();
		}
	}
	public class PvpController : MonoBehaviour
	{
		private struct FreezeHold
		{
			public Player Player;

			public Vector3 Pos;

			public float Yaw;
		}

		private static readonly string[] FallbackWeapons = new string[18]
		{
			"pistol", "revolver", "shotgun", "rifle", "smg", "sniper", "ak", "m4", "glock", "deagle",
			"crossbow", "knife", "dynamite", "knuckles", "brassknuckles", "brass knuckles", "grenade", "bat"
		};

		private static List<Item> _dropPrefabs;

		private static int _dropAt;

		private static int _customsThisRound;

		private static int _customsThisMatch;

		private Coroutine _match;

		private Coroutine _lobbyMove;

		private Coroutine _rain;

		private float _nextShopHide;

		private float _nextLobbyPulse;

		private static int _dropSector;

		private static readonly List<FreezeHold> _freeze = new List<FreezeHold>();

		private static readonly List<Vector3> _roundPos = new List<Vector3>();

		private static readonly List<float> _roundYaw = new List<float>();

		internal static bool QuietTeleport;

		private static int _lastIsland = -1;

		internal static bool HostNow()
		{
			return IsHost();
		}

		private void Update()
		{
			TryQueueFromSaveName();
			PvpSync.Tick();
			if (!PvpSession.Queued)
			{
				MenuPatch.TryAttachIfNeeded();
			}
			if (!PvpSession.Queued)
			{
				return;
			}
			if (IsHost() && !PvpSession.LobbyMoved && !PvpSession.MatchRunning && (Object)(object)OnlineIslandManager.Instance != (Object)null && PlayerCount() > 0)
			{
				StartLobbyMove();
			}
			if (PvpLobby.IsSkyLobby())
			{
				PvpLobby.Ensure();
				PvpLobby.SetGod(on: true);
				PvpLobby.ForceHealth(Player.LocalPlayer);
				if ((Object)(object)Player.LocalPlayer != (Object)null)
				{
					ClearDeadFlag(Player.LocalPlayer);
				}
			}
			else
			{
				PvpLobby.SetGod(on: false);
			}
			if (IsHost() && PvpSession.MatchRunning && PvpSession.Phase == PvpPhase.Countdown && PvpSession.CountdownDisplay > 0)
			{
				HoldFrozen();
			}
			PvpFlood.Tick();
			PvpWinnerCam.Tick();
			if (IsHost() && PvpSession.Queued && (Time.time < PvpSession.ProtectUntil || IslandManager.IsLoading || PvpLobby.IsSkyLobby()))
			{
				KeepPlayersAlive();
			}
			if (!IsHost())
			{
				SyncBalancePads();
			}
			if (IsHost() && PvpSession.Queued)
			{
				KeepPlayersFed();
			}
			IslandPatch.TickClean();
			PvpBoats.Tick();
			if (PvpSession.Queued && Time.time >= _nextShopHide)
			{
				_nextShopHide = Time.time + 1.25f;
				HideShops();
			}
			if (IsHost() && PvpSession.Queued && !PvpSession.MatchRunning && PvpSession.Phase != PvpPhase.MatchOver && Time.time >= _nextLobbyPulse)
			{
				_nextLobbyPulse = Time.time + 4f;
				PvpSync.Send("waiting for players");
			}
			if (Input.GetKeyDown((KeyCode)289) && IsHost() && !PvpSession.MatchRunning)
			{
				StartMatch();
			}
		}

		private void TryQueueFromSaveName()
		{
			if (!PvpSession.Queued)
			{
				ServerSaveObject curServerSave = SaveManager.CurServerSave;
				if (curServerSave != null && !string.IsNullOrEmpty(curServerSave.Name) && curServerSave.Name.IndexOf("PVP", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					PvpSession.EnsureQueued();
					PvpSession.Phase = PvpPhase.WaitingForPlayers;
					PvpSession.SubBanner = "Waiting for players... host press F8 to start";
					MenuPatch.ApplyPvpSaveIslands();
				}
			}
		}

		private void StartLobbyMove()
		{
			if (_lobbyMove == null)
			{
				PvpSession.LobbyMoved = true;
				_lobbyMove = ((MonoBehaviour)this).StartCoroutine(MoveLobbyToForest());
			}
		}

		private IEnumerator MoveLobbyToForest()
		{
			PvpSession.ProtectUntil = Time.time + 20f;
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)Server.Instance != (Object)null && ((NetworkBehaviour)Server.Instance).IsServerInitialized));
			if (CurrentIsland() != 1)
			{
				GoToIsland(1);
				yield return WaitForLiveSpawn(1);
			}
			else
			{
				yield return WaitForLiveSpawn(1);
			}
			PvpSession.IslandIndex = 1;
			try
			{
				GameInfo.ToggleAllCreaturesKilled(true, false);
			}
			catch
			{
			}
			PlacePlayersSafely(strip: false);
			RestoreAllViews();
			HideShops();
			PvpSession.ProtectUntil = Time.time + 8f;
			PvpSession.SubBanner = "Waiting for players... host press F8 to start";
			PvpSync.Send("waiting for players");
			Debug.Log((object)("[HowToFishPvp] Forest lobby at " + ((object)SpawnPos()/*cast due to .constrained prefix*/).ToString()));
			PvpSession.LobbyReady = true;
			_lobbyMove = null;
		}

		private void StartMatch()
		{
			if (_match != null)
			{
				((MonoBehaviour)this).StopCoroutine(_match);
			}
			_match = ((MonoBehaviour)this).StartCoroutine(RunMatch());
		}

		private IEnumerator RunMatch()
		{
			PvpSession.MatchRunning = true;
			PvpSession.Phase = PvpPhase.WaitingForPlayers;
			PvpSession.SubBanner = "Setting up PVP...";
			_lastIsland = -1;
			ClearFreeze();
			PvpSession.BalanceRound = 0;
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)Server.Instance != (Object)null && ((NetworkBehaviour)Server.Instance).IsServerInitialized));
			yield return (object)new WaitForSeconds(1.5f);
			if ((Object)(object)ServerSettings.Instance != (Object)null)
			{
				ServerSettings.Instance.ToggleFriendlyFire(true);
			}
			UnlockAllIslands();
			try
			{
				GameInfo.ToggleAllCreaturesKilled(true, false);
			}
			catch
			{
			}
			while (PvpSession.Queued && PvpSession.MatchRunning)
			{
				PvpSession.Scores.Clear();
				PvpSession.Names.Clear();
				PvpSession.Round = 0;
				PvpSession.FloodState = 0;
				PvpSession.CenterBanner = "";
				PvpSession.SpectateSteam = 0uL;
				PvpFlood.Restore();
				PvpWinnerCam.Stop();
				PvpSession.MapSeed = Random.Range(1, 2000000000);
				PvpArena.Roll(PvpSession.MapSeed);
				_customsThisMatch = 0;
				for (int round = 1; round <= 20; round++)
				{
					yield return RunRound(round);
					if (!PvpSession.Queued || !PvpSession.MatchRunning)
					{
						_match = null;
						yield break;
					}
					if (round < 20)
					{
						yield return null;
					}
				}
				yield return ShowWinner();
				if (!PvpSession.Queued || !PvpSession.MatchRunning)
				{
					break;
				}
				PvpSync.Send("newmatch");
				yield return (object)new WaitForSeconds(1.2f);
			}
			PvpWinnerCam.Stop();
			PvpFlood.Restore();
			PvpSession.MatchRunning = false;
			_match = null;
		}

		private IEnumerator ShowWinner()
		{
			PvpSession.Phase = PvpPhase.MatchOver;
			PvpSession.ProtectUntil = Time.time + 20f;
			KeepPlayersAlive();
			RestoreAllViews();
			StopRain();
			Player val = HighestScorePlayer();
			PvpWinnerCam.Start(val);
			string text = (((Object)(object)val != (Object)null && !string.IsNullOrEmpty(val.SteamName)) ? val.SteamName : WinnerName());
			PvpSession.SubBanner = "WINNER — " + text;
			Announce("winner " + PvpSession.SpectateSteam + " " + text);
			yield return (object)new WaitForSeconds(8f);
			PvpWinnerCam.Stop();
			RestoreAllViews();
			PvpSession.Round = 0;
			PvpSession.Scores.Clear();
			PvpSession.CenterBanner = "";
			PvpSession.SpectateSteam = 0uL;
			PvpSession.Phase = PvpPhase.WaitingForPlayers;
		}

		private IEnumerator RunRound(int round)
		{
			PvpSession.Round = round;
			PvpSession.IslandIndex = PickPvpIsland(round);
			PvpSession.CountdownDisplay = -1;
			PvpSession.Phase = PvpPhase.Countdown;
			ArenaMap map = PvpArena.ForRound(round);
			string text = PvpArena.Title(map);
			PvpSession.SubBanner = (string.IsNullOrEmpty(text) ? ("Round " + round) : ("Round " + round + " — " + text));
			Announce("PVP Round " + round + "/" + 20 + (string.IsNullOrEmpty(text) ? "" : (" (" + text + ")")));
			PvpSession.ProtectUntil = Time.time + 20f;
			GoToIsland((byte)PvpSession.IslandIndex);
			yield return WaitForLiveSpawn(PvpSession.IslandIndex);
			yield return (object)new WaitForFixedUpdate();
			Physics.SyncTransforms();
			PvpLobby.DestroyPad();
			PvpBalance.Destroy();
			PvpLava.Destroy();
			PvpArena.Destroy();
			switch (map)
			{
			case ArenaMap.Benches:
				PvpBalance.Build(Mathf.Max(1, PlayerCount()));
				yield return null;
				Physics.SyncTransforms();
				break;
			default:
				PvpArena.Build(map, Mathf.Max(1, PlayerCount()));
				yield return null;
				Physics.SyncTransforms();
				break;
			case ArenaMap.None:
				break;
			}
			WipeCombatItems();
			PlacePlayersSafely(strip: true);
			WipeCombatItems();
			HideShops();
			PvpSession.ProtectUntil = Time.time + 12f;
			yield return (object)new WaitForSeconds(0.25f);
			PlacePlayersSafely(strip: false, settle: true);
			CaptureFreeze();
			yield return RunCountdown();
			ClearFreeze();
			PvpBoats.SeatPlayers();
			PvpFlood.BeginRound();
			PvpSession.ProtectUntil = Time.time + 1.5f;
			PvpSession.Phase = PvpPhase.Fighting;
			PvpSession.FightStartedAt = Time.time;
			PvpSession.RoundEndsAt = Time.time + 90f;
			StartRain();
			while (true)
			{
				int num = AliveCount();
				if ((PlayerCount() >= 2 && num <= 1) || Input.GetKeyDown((KeyCode)290) || Time.time - PvpSession.FightStartedAt > 150f)
				{
					break;
				}
				yield return null;
			}
			PvpFlood.EndRound();
			Player val = LastAliveOrHealthiest();
			PvpSession.ProtectUntil = Time.time + 12f;
			KeepPlayersAlive();
			UnstickAlive();
			StopRain();
			WipeCombatItems();
			PvpSession.Phase = PvpPhase.RoundOver;
			PvpSession.CountdownDisplay = -1;
			if ((Object)(object)val != (Object)null)
			{
				PvpSession.AwardRound(val);
				PvpSession.SubBanner = val.SteamName + " wins round " + round;
			}
			else
			{
				PvpSession.SubBanner = "Round " + round + " — no winner";
			}
			Announce(PvpSession.SubBanner);
		}

		private IEnumerator RunCountdown()
		{
			PvpSession.Phase = PvpPhase.Countdown;
			for (int n = 3; n >= 1; n--)
			{
				PvpSession.CountdownDisplay = n;
				PvpSession.SubBanner = "";
				PvpSync.Send(n.ToString());
				yield return (object)new WaitForSeconds(1f);
			}
			PvpSession.CountdownDisplay = 0;
			PvpSync.Send("GO");
			ClearFreeze();
			yield return (object)new WaitForSeconds(0.7f);
			PvpSession.CountdownDisplay = -1;
		}

		private static IEnumerator WaitForLiveSpawn(int wantIsland)
		{
			float t = 0f;
			while (t < 14f)
			{
				if (!IslandManager.IsLoading && TryGetLiveSpawn(out var _, out var _) && SpawnMatchesIsland(wantIsland))
				{
					yield return (object)new WaitForSeconds(0.4f);
					yield return (object)new WaitForFixedUpdate();
					break;
				}
				t += Time.deltaTime;
				yield return null;
			}
		}

		private static bool SpawnMatchesIsland(int island)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (island < 0)
			{
				return true;
			}
			Scene val = IslandScene();
			if (!((Scene)(ref val)).IsValid())
			{
				return true;
			}
			int num = island + 1;
			if (((Scene)(ref val)).buildIndex == num)
			{
				return true;
			}
			try
			{
				if ((Object)(object)OnlineIslandManager.Instance != (Object)null && OnlineIslandManager.CurIsland == (byte)island)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private static void PlacePlayersSafely(bool strip, bool settle = false)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			List<Player> list = SnapshotPlayers();
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				if ((Object)(object)list[i] != (Object)null)
				{
					num++;
				}
			}
			if (num < 1 || ((!settle || _roundPos.Count != num) && !ComputeRoundSlots(num)))
			{
				return;
			}
			PvpCloak.ClearRound();
			int num2 = 0;
			for (int j = 0; j < list.Count; j++)
			{
				Player val = list[j];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				PvpSession.EnsurePlayer(val);
				if (num2 >= _roundPos.Count)
				{
					break;
				}
				Vector3 pos = _roundPos[num2];
				float yaw = ((num2 < _roundYaw.Count) ? _roundYaw[num2] : 0f);
				if (!settle)
				{
					ReviveAt(val, pos, yaw);
					if (strip)
					{
						StripOnly(val, pos);
					}
					RestorePlayerView(val);
					Snap(val, pos, yaw);
					StopFall(val);
					RestorePlayerView(val);
				}
				else
				{
					Snap(val, pos, yaw);
					StopFall(val);
					RestorePlayerView(val);
				}
				num2++;
			}
		}

		private static bool ComputeRoundSlots(int n)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			_roundPos.Clear();
			_roundYaw.Clear();
			Vector3 pos = Vector3.zero;
			float yaw = 0f;
			if (!PvpArena.IsActive && !PvpBalance.IsActive && !TryGetLiveSpawn(out pos, out yaw))
			{
				Debug.LogWarning((object)"[HowToFishPvp] No live island spawn yet.");
				return false;
			}
			float standOff = StandOffset(pos);
			int mask = GroundMask();
			float water = WaterAt(pos);
			for (int i = 0; i < n; i++)
			{
				if ((!PvpArena.IsActive || !PvpArena.TryGetSlot(i, n, out var pos2, out var yaw2)) && (!PvpBalance.IsActive || !PvpBalance.TryGetSlot(i, n, out pos2, out yaw2)))
				{
					pos2 = PadSpawn(pos, yaw, i, n, standOff, water, mask, out yaw2);
				}
				_roundPos.Add(pos2);
				_roundYaw.Add(yaw2);
			}
			return _roundPos.Count > 0;
		}

		private static void KeepPlayersFed()
		{
			List<Player> list = SnapshotPlayers();
			for (int i = 0; i < list.Count; i++)
			{
				Player val = list[i];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.Vitals == (Object)null) && val.Vitals.Fullness < 100)
				{
					try
					{
						val.Vitals.RestoreFullness(100);
					}
					catch
					{
					}
				}
			}
		}

		private static void SyncBalancePads()
		{
			if (!PvpSession.Queued || !PvpSession.MatchRunning)
			{
				if (PvpBalance.IsActive)
				{
					PvpBalance.Destroy();
				}
				if (PvpLava.IsActive)
				{
					PvpLava.Destroy();
				}
				if (PvpArena.IsActive)
				{
					PvpArena.Destroy();
				}
			}
			else
			{
				if (IslandManager.IsLoading)
				{
					return;
				}
				ArenaMap arenaMap = PvpArena.ForRound(PvpSession.Round);
				if (PvpLava.IsActive)
				{
					PvpLava.Destroy();
				}
				switch (arenaMap)
				{
				case ArenaMap.None:
					if (PvpBalance.IsActive)
					{
						PvpBalance.Destroy();
					}
					if (PvpArena.IsActive)
					{
						PvpArena.Destroy();
					}
					break;
				case ArenaMap.Benches:
					if (PvpArena.IsActive)
					{
						PvpArena.Destroy();
					}
					if (!PvpBalance.IsActive || PvpBalance.PadCount < PlayerCount() || PlayerCount() <= 0)
					{
						PvpBalance.Build(Mathf.Max(1, PlayerCount()));
					}
					break;
				default:
					if (PvpBalance.IsActive)
					{
						PvpBalance.Destroy();
					}
					if (!PvpArena.IsActive || PvpArena.Built != arenaMap)
					{
						PvpArena.Build(arenaMap, Mathf.Max(1, PlayerCount()));
					}
					break;
				}
			}
		}

		private static void KeepPlayersAlive()
		{
			List<Player> list = SnapshotPlayers();
			for (int i = 0; i < list.Count; i++)
			{
				Player val = list[i];
				if ((Object)(object)val == (Object)null || (Object)(object)val.Vitals == (Object)null)
				{
					continue;
				}
				if (PvpLobby.IsSkyLobby())
				{
					ClearDeadFlag(val);
					PvpLobby.ForceHealth(val);
				}
				else if (val.Vitals.Health <= 0)
				{
					if (!PvpSession.MatchRunning || PvpSession.Phase != PvpPhase.Fighting)
					{
						val.Vitals.ServerResetVitals();
					}
				}
				else if (Time.time < PvpSession.ProtectUntil)
				{
					val.Vitals.ServerResetVitals();
				}
			}
		}

		private static bool TryGetLiveSpawn(out Vector3 pos, out float yaw)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			pos = Vector3.zero;
			yaw = 0f;
			if (PvpArena.TryGetSpawn(out pos, out yaw))
			{
				return true;
			}
			if (PvpBalance.TryGetSpawn(out pos, out yaw))
			{
				return true;
			}
			if (PvpLobby.IsSkyLobby() && PvpLobby.TryGetSpawn(out pos, out yaw))
			{
				return true;
			}
			Scene val = IslandScene();
			Vector3 val2 = Vector3.zero;
			float num = 0f;
			bool flag = false;
			try
			{
				SpawnManager[] array = Object.FindObjectsOfType<SpawnManager>();
				if (array != null)
				{
					foreach (SpawnManager val3 in array)
					{
						if ((Object)(object)val3 == (Object)null || !((Behaviour)val3).isActiveAndEnabled)
						{
							continue;
						}
						Scene scene = ((Component)val3).gameObject.scene;
						if (!((Scene)(ref scene)).IsValid())
						{
							continue;
						}
						scene = ((Component)val3).gameObject.scene;
						if (!((Scene)(ref scene)).isLoaded)
						{
							continue;
						}
						object? value = AccessTools.Field(typeof(SpawnManager), "_playerSpawnPoint").GetValue(val3);
						Transform val4 = (Transform)((value is Transform) ? value : null);
						if ((Object)(object)val4 == (Object)null)
						{
							continue;
						}
						Vector3 position = val4.position;
						if (!(((Vector3)(ref position)).sqrMagnitude < 0.01f))
						{
							if (!((Scene)(ref val)).IsValid() || !(((Component)val3).gameObject.scene != val))
							{
								pos = val4.position;
								yaw = val4.eulerAngles.y;
								return true;
							}
							if (!flag)
							{
								val2 = val4.position;
								num = val4.eulerAngles.y;
								flag = true;
							}
						}
					}
				}
			}
			catch
			{
			}
			if (flag)
			{
				pos = val2;
				yaw = num;
				return true;
			}
			return false;
		}

		private static Scene IslandScene()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)Island.CurIsland != (Object)null)
				{
					return ((Component)Island.CurIsland).gameObject.scene;
				}
			}
			catch
			{
			}
			try
			{
				int num = CurrentIsland() + 1;
				for (int i = 0; i < SceneManager.sceneCount; i++)
				{
					Scene sceneAt = SceneManager.GetSceneAt(i);
					if (((Scene)(ref sceneAt)).IsValid() && ((Scene)(ref sceneAt)).isLoaded && ((Scene)(ref sceneAt)).buildIndex == num)
					{
						return sceneAt;
					}
				}
			}
			catch
			{
			}
			return default(Scene);
		}

		private static Vector3 PadSpawn(Vector3 spawn, float spawnYaw, int index, int count, float standOff, float water, int mask, out float faceYaw)
		{
			//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)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			if (count < 1)
			{
				count = 1;
			}
			Vector3 val = spawn;
			if (count > 1)
			{
				float num = ((count == 2) ? 3.4f : Mathf.Clamp(3f + (float)count * 0.35f, 3.2f, 5.5f));
				float num2 = 360f / (float)count;
				float num3 = spawnYaw + (float)index * num2 + num2 * 0.5f;
				bool flag = false;
				float[] array = new float[5]
				{
					num,
					num * 0.72f,
					num * 0.5f,
					1.6f,
					0.8f
				};
				float[] array2 = new float[5] { 0f, 18f, -18f, 40f, -40f };
				for (int i = 0; i < array.Length; i++)
				{
					if (flag)
					{
						break;
					}
					for (int j = 0; j < array2.Length; j++)
					{
						if (GroundAt(spawn + Quaternion.Euler(0f, num3 + array2[j], 0f) * Vector3.forward * array[i], spawn, water, standOff, mask, out var stand))
						{
							val = stand;
							flag = true;
							break;
						}
					}
				}
				if (!flag)
				{
					Vector3 val2 = Quaternion.Euler(0f, spawnYaw + ((index == 0) ? (-90f) : 90f), 0f) * Vector3.forward;
					val = spawn + val2 * 1.4f;
					val.y = spawn.y;
				}
			}
			Vector3 val3 = spawn - val;
			val3.y = 0f;
			if (((Vector3)(ref val3)).sqrMagnitude > 0.05f)
			{
				faceYaw = Mathf.Atan2(val3.x, val3.z) * 57.29578f;
			}
			else
			{
				faceYaw = spawnYaw + 180f;
			}
			return val;
		}

		private static float StandOffset(Vector3 spawn)
		{
			//IL_0006: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			int num = GroundMask();
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(spawn + Vector3.up * 1.4f, Vector3.down, ref val, 3.2f, num, (QueryTriggerInteraction)1))
			{
				return Mathf.Clamp(spawn.y - ((RaycastHit)(ref val)).point.y, 0.04f, 1.25f);
			}
			return 0.9f;
		}

		private static bool GroundAt(Vector3 around, Vector3 spawn, float water, float standOff, int mask, out Vector3 stand)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			stand = around;
			stand.y = spawn.y;
			RaycastHit[] array = Physics.RaycastAll(new Vector3(around.x, spawn.y + 1.7f, around.z), Vector3.down, 3.6f, mask, (QueryTriggerInteraction)1);
			if (array == null || array.Length == 0)
			{
				return false;
			}
			float num = float.MaxValue;
			bool flag = false;
			Vector3 val = stand;
			RaycastHit val3 = default(RaycastHit);
			for (int i = 0; i < array.Length; i++)
			{
				RaycastHit val2 = array[i];
				if (!((Object)(object)((RaycastHit)(ref val2)).collider == (Object)null) && !(((RaycastHit)(ref val2)).normal.y < 0.62f) && !(((RaycastHit)(ref val2)).point.y < water + 0.9f) && !(((RaycastHit)(ref val2)).point.y > spawn.y + 1.35f) && !(((RaycastHit)(ref val2)).point.y < spawn.y - 1.15f) && !Physics.Raycast(((RaycastHit)(ref val2)).point + Vector3.up * 0.12f, Vector3.up, ref val3, 1.7f, mask, (QueryTriggerInteraction)1))
				{
					float num2 = Mathf.Abs(((RaycastHit)(ref val2)).point.y - spawn.y);
					if (num2 < num)
					{
						num = num2;
						((Vector3)(ref val))..ctor(((RaycastHit)(ref val2)).point.x, ((RaycastHit)(ref val2)).point.y + standOff, ((RaycastHit)(ref val2)).point.z);
						flag = true;
					}
				}
			}
			if (!flag)
			{
				return false;
			}
			stand = val;
			return true;
		}

		private static int GroundMask()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			try
			{
				num = LayerMask.op_Implicit(GameInfo.LevelLayer);
			}
			catch
			{
			}
			try
			{
				num |= LayerMask.op_Implicit(GameInfo.CanJumpOnLayers);
			}
			catch
			{
			}
			if (num == 0)
			{
				num = -5;
			}
			return num;
		}

		private static float WaterAt(Vector3 at)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return WaterManager.GetWaterHeight(at);
			}
			catch
			{
				try
				{
					return WaterManager.WaterHeight;
				}
				catch
				{
				}
			}
			return -20f;
		}

		private static Vector3 SpawnPos()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			TryGetLiveSpawn(out var pos, out var _);
			return pos;
		}

		private static void ReviveAt(Player player, Vector3 pos, float yaw)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player.Vitals == (Object)null)
			{
				return;
			}
			try
			{
				player.Vitals.ServerResetVitals();
			}
			catch
			{
			}
		}

		private static void StripOnly(Player player, Vector3 pos)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)player != (Object)null && (Object)(object)player.Inventory != (Object)null)
				{
					player.Inventory.ServerDropAll(pos, ((Component)player).transform.rotation);
				}
			}
			catch
			{
			}
		}

		private static void Teleport(Player player, Vector3 pos, float yaw)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Snap(player, pos, yaw);
			RestorePlayerView(player);
		}

		private static void Snap(Player player, Vector3 pos, float yaw)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			QuietTeleport = true;
			try
			{
				try
				{
					player.LocalTeleport(pos, yaw, true);
				}
				catch
				{
				}
				Server instance = Server.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.RpcLogic___TeleportPlayer___3852204532(player, pos, yaw);
				}
				StopFall(player);
			}
			finally
			{
				QuietTeleport = false;
			}
		}

		private static float LookYaw(Player player, float fallback)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)player != (Object)null && (Object)(object)player.CamObject != (Object)null)
				{
					return player.CamObject.eulerAngles.y;
				}
			}
			catch
			{
			}
			return fallback;
		}

		private static void StopFall(Player player)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			try
			{
				PlayerMovement movement = player.Movement;
				if ((Object)(object)movement != (Object)null)
				{
					AccessTools.Field(typeof(PlayerMovement), "_isSwimming").SetValue(movement, false);
				}
				object? value = AccessTools.Field(typeof(PlayerMovement), "_rig").GetValue(movement);
				Rigidbody val = (Rigidbody)((value is Rigidbody) ? value : null);
				if ((Object)(object)val != (Object)null)
				{
					val.linearVelocity = Vector3.zero;
				}
			}
			catch
			{
			}
		}

		private static void CaptureFreeze()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			_freeze.Clear();
			List<Player> list = SnapshotPlayers();
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				Player val = list[i];
				if (!((Object)(object)val == (Object)null))
				{
					Vector3 pos = ((num < _roundPos.Count) ? _roundPos[num] : BodyPos(val));
					float yaw = ((num < _roundYaw.Count) ? _roundYaw[num] : LookYaw(val, 0f));
					_freeze.Add(new FreezeHold
					{
						Player = val,
						Pos = pos,
						Yaw = yaw
					});
					num++;
				}
			}
		}

		private static void ClearFreeze()
		{
			_freeze.Clear();
		}

		private static void HoldFrozen()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (PvpBoats.IsRound)
			{
				PvpBoats.Hold(freeze: true);
			}
			if (_freeze.Count == 0)
			{
				return;
			}
			for (int i = 0; i < _freeze.Count; i++)
			{
				FreezeHold freezeHold = _freeze[i];
				Player player = freezeHold.Player;
				if (!((Object)(object)player == (Object)null))
				{
					StopFall(player);
					Vector3 val = BodyPos(player);
					float num = val.x - freezeHold.Pos.x;
					float num2 = val.z - freezeHold.Pos.z;
					if (num * num + num2 * num2 > 6.25f)
					{
						Snap(player, freezeHold.Pos, freezeHold.Yaw);
					}
				}
			}
		}

		internal static void RestoreAllViews()
		{
			List<Player> list = SnapshotPlayers();
			for (int i = 0; i < list.Count; i++)
			{
				RestorePlayerView(list[i]);
			}
		}

		private static void UnstickAlive()
		{
			List<Player> list = SnapshotPlayers();
			for (int i = 0; i < list.Count; i++)
			{
				Player val = list[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					if ((Object)(object)val.Dying != (Object)null && val.Dying.IsDead)
					{
						continue;
					}
				}
				catch
				{
				}
				try
				{
					if ((Object)(object)val.Vitals != (Object)null && val.Vitals.Health <= 0)
					{
						continue;
					}
				}
				catch
				{
				}
				PvpGrab.ResetPose(val);
			}
		}

		internal static void RestorePlayerView(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			try
			{
				if ((Object)(object)player.Dying != (Object)null && player.Dying.IsDead)
				{
					AccessTools.Field(typeof(PlayerDying), "<IsDead>k__BackingField").SetValue(player.Dying, false);
				}
			}
			catch
			{
			}
			try
			{
				PlayerManager.OnPlayerResurrected(player);
			}
			catch
			{
			}
			PvpGrab.ResetPose(player);
			RestoreVisuals(player);
		}

		internal static void ClearDeadFlag(Player player)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player.Dying == (Object)null)
			{
				return;
			}
			bool flag = false;
			try
			{
				flag = player.Dying.IsDead;
				if (flag)
				{
					AccessTools.Field(typeof(PlayerDying), "<IsDead>k__BackingField").SetValue(player.Dying, false);
				}
			}
			catch
			{
			}
			if (!flag)
			{
				return;
			}
			try
			{
				PlayerManager.OnPlayerResurrected(player);
			}
			catch
			{
			}
		}

		internal static void RestoreVisuals(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			try
			{
				if (PvpSession.Phase == PvpPhase.Fighting && (Object)(object)player.Dying != (Object)null && player.Dying.IsDead)
				{
					return;
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)player.Transform != (Object)null && (Object)(object)((Component)player.Transform).gameObject != (Object)null)
				{
					((Component)player.Transform).gameObject.SetActive(true);
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)player.Hands != (Object)null)
				{
					player.Hands.ToggleHandMeshes(true);
				}
			}
			catch
			{
			}
			PvpGrab.UnstickArms(player);
			try
			{
				if ((Object)(object)player.Other != (Object)null && (Object)(object)player.Other.Transform != (Object)null)
				{
					((Component)player.Other.Transform).gameObject.SetActive(true);
				}
			}
			catch
			{
			}
			if ((Object)(object)player != (Object)(object)Player.LocalPlayer || PvpSession.Phase == PvpPhase.MatchOver)
			{
				return;
			}
			try
			{
				Player.ToggleLocalPlayer(true);
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)player.DeathCam != (Object)null)
				{
					player.DeathCam.DisableDeathCam();
				}
			}
			catch
			{
			}
			try
			{
				PlayerUI.ToggleDeathUI(false);
			}
			catch
			{
			}
			try
			{
				if (AccessTools.Field(typeof(Player), "_localObjects").GetValue(player) is List<GameObject> list)
				{
					for (int i = 0; i < list.Count; i++)
					{
						if ((Object)(object)list[i] != (Object)null)
						{
							list[i].SetActive(true);
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				if (AccessTools.Field(typeof(Player), "_otherObjects").GetValue(player) is List<GameObject> list2)
				{
					for (int j = 0; j < list2.Count; j++)
					{
						if ((Object)(object)list2[j] != (Object)null)
						{
							list2[j].SetActive(false);
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)player.Camera != (Object)null && (Object)(object)player.Camera.Cam != (Object)null)
				{
					player.SetCurCam(player.Camera.Cam);
				}
			}
			catch
			{
			}
		}

		private void StartRain()
		{
			StopRain();
			_dropPrefabs = null;
			_customsThisRound = 0;
			_rain = ((MonoBehaviour)this).StartCoroutine(RainWeapons());
		}

		private void StopRain()
		{
			if (_rain != null)
			{
				((MonoBehaviour)this).StopCoroutine(_rain);
				_rain = null;
			}
		}

		private IEnumerator RainWeapons()
		{
			yield return (object)new WaitForSeconds(0.25f);
			int n = Mathf.Max(2, PlayerCount() * 2);
			for (int i = 0; i < n; i++)
			{
				DropOneWeapon();
				yield return (object)new WaitForSeconds(0.14f);
			}
			while (PvpSession.MatchRunning && PvpSession.Phase == PvpPhase.Fighting)
			{
				yield return (object)new WaitForSeconds(Random.Range(6f, 11f));
				if (PvpSession.Phase == PvpPhase.Fighting)
				{
					DropOneWeapon();
				}
			}
			_rain = null;
		}

		private static Vector3 BodyPos(Player p)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)p == (Object)null)
			{
				return Vector3.zero;
			}
			try
			{
				if ((Object)(object)p.Transform != (Object)null)
				{
					return p.Transform.position;
				}
			}
			catch
			{
			}
			return ((Component)p).transform.position;
		}

		private static Vector3 PickDropLand()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (PvpArena.IsActive || PvpBalance.IsActive)
			{
				return PickCloseDrop();
			}
			return PickIslandFair();
		}

		private static Vector3 PickCloseDrop()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = AlivePositions();
			int mask = DropMask();
			for (int i = 0; i < 14; i++)
			{
				Vector3 val = ((list.Count > 0) ? list[Random.Range(0, list.Count)] : DropOrigin());
				float num = Random.Range(1.2f, 4.8f);
				float num2 = Random.Range(0f, 360f) * ((float)Math.PI / 180f);
				if (DropWalkable(val + new Vector3(Mathf.Cos(num2) * num, 0f, Mathf.Sin(num2) * num), mask, out var land) && NearAny(land, list, 7.5f))
				{
					return land;
				}
			}
			if (PvpArena.TryRandomDrop(out var pos) && NearAny(pos, list, 8f))
			{
				return pos;
			}
			if (list.Count > 0)
			{
				return list[Random.Range(0, list.Count)];
			}
			return DropOrigin();
		}

		private static Vector3 PickIslandFair()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = AlivePositions();
			if (TryIslandSpawnPoint(out var pos, out var _) && ((Vector3)(ref pos)).sqrMagnitude > 0.01f)
			{
				list.Add(pos);
			}
			Vector3 val = Vector3.zero;
			if (list.Count == 0)
			{
				val = DropOrigin();
			}
			else
			{
				for (int i = 0; i < list.Count; i++)
				{
					val += list[i];
				}
				val /= (float)list.Count;
			}
			float num = 22f;
			for (int j = 0; j < list.Count; j++)
			{
				Vector3 val2 = list[j] - val;
				val2.y = 0f;
				num = Mathf.Max(num, ((Vector3)(ref val2)).magnitude * 1.7f + 10f);
			}
			num = Mathf.Clamp(num, 22f, 52f);
			int mask = DropMask();
			for (int k = 0; k < 22; k++)
			{
				float num2 = ((float)(_dropSector++ % 8) + Random.value) * 45f * ((float)Math.PI / 180f);
				float num3 = Random.Range(num * 0.12f, num);
				if (DropWalkable(val + new Vector3(Mathf.Cos(num2) * num3, 0f, Mathf.Sin(num2) * num3), mask, out var land))
				{
					return land;
				}
			}
			if (list.Count > 0)
			{
				Vector3 val3 = list[Random.Range(0, list.Count)];
				float num4 = Random.Range(0f, 360f) * ((float)Math.PI / 180f);
				float num5 = Random.Range(6f, 16f);
				if (DropWalkable(val3 + new Vector3(Mathf.Cos(num4) * num5, 0f, Mathf.Sin(num4) * num5), mask, out var land2))
				{
					return land2;
				}
				return val3;
			}
			return val;
		}

		private static List<Vector3> AlivePositions()
		{
			//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_005c: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			List<Player> list2 = SnapshotPlayers();
			for (int i = 0; i < list2.Count; i++)
			{
				Player val = list2[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					if ((Object)(object)val.Vitals != (Object)null && val.Vitals.Health <= 0)
					{
						continue;
					}
				}
				catch
				{
				}
				Vector3 item = BodyPos(val);
				if (!(((Vector3)(ref item)).sqrMagnitude < 0.01f))
				{
					list.Add(item);
				}
			}
			return list;
		}

		private static bool NearAny(Vector3 point, List<Vector3> spots, float maxDist)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (spots == null || spots.Count == 0)
			{
				return true;
			}
			float num = maxDist * maxDist;
			for (int i = 0; i < spots.Count; i++)
			{
				Vector3 val = point - spots[i];
				val.y = 0f;
				if (((Vector3)(ref val)).sqrMagnitude <= num)
				{
					return true;
				}
			}
			return false;
		}

		private static int DropMask()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			try
			{
				num = LayerMask.op_Implicit(GameInfo.LevelLayer);
			}
			catch
			{
			}
			try
			{
				num |= LayerMask.op_Implicit(GameInfo.CanJumpOnLayers);
			}
			catch
			{
			}
			if (num == 0)
			{
				num = -5;
			}
			return num;
		}

		private static bool DropWalkable(Vector3 around, int mask, out Vector3 land)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			land = around;
			float num = -999f;
			try
			{
				num = WaterManager.GetWaterHeight(around);
			}
			catch
			{
				try
				{
					num = WaterManager.WaterHeight;
				}
				catch
				{
				}
			}
			RaycastHit[] array = Physics.RaycastAll(around + Vector3.up * 18f, Vector3.down, 46f, mask, (QueryTriggerInteraction)1);
			if (array == null || array.Length == 0)
			{
				return false;
			}
			Array.Sort(array, (RaycastHit a, RaycastHit b) => ((RaycastHit)(ref b)).point.y.CompareTo(((RaycastHit)(ref a)).point.y));
			for (int num2 = 0; num2 < array.Length; num2++)
			{
				RaycastHit val = array[num2];
				if (!((Object)(object)((RaycastHit)(ref val)).collider == (Object)null) && !(((RaycastHit)(ref val)).normal.y < 0.35f) && (!(num > -900f) || !(((RaycastHit)(ref val)).point.y < num + 0.45f)))
				{
					land = ((RaycastHit)(ref val)).point;
					return true;
				}
			}
			return false;
		}

		private static Vector3 DropOrigin()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_006c: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.zero;
			int num = 0;
			List<Player> list = SnapshotPlayers();
			for (int i = 0; i < list.Count; i++)
			{
				Player val2 = list[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				try
				{
					if ((Object)(object)val2.Vitals != (Object)null && val2.Vitals.Health <= 0)
					{
						continue;
					}
				}
				catch
				{
				}
				Vector3 val3 = BodyPos(val2);
				if (!(((Vector3)(ref val3)).sqrMagnitude < 0.01f))
				{
					val += val3;
					num++;
				}
			}
			if (num > 0)
			{
				return val / (float)num;
			}
			if ((Object)(object)Player.LocalPlayer != (Object)null)
			{
				return BodyPos(Player.LocalPlayer);
			}
			if (TryIslandSpawnPoint(out var pos, out var _))
			{
				return pos;
			}
			return Vector3.zero;
		}

		private static bool TryIslandSpawnPoint(out Vector3 pos, out float yaw)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			pos = Vector3.zero;
			yaw = 0f;
			try
			{
				SpawnManager[] array = Object.FindObjectsOfType<SpawnManager>();
				if (array == null)
				{
					return false;
				}
				Scene val = IslandScene();
				foreach (SpawnManager val2 in array)
				{
					if ((Object)(object)val2 == (Object)null || !((Behaviour)val2).isActiveAndEnabled || (((Scene)(ref val)).IsValid() && ((Component)val2).gameObject.scene != val))
					{
						continue;
					}
					object? value = AccessTools.Field(typeof(SpawnManager), "_playerSpawnPoint").GetValue(val2);
					Transform val3 = (Transform)((value is Transform) ? value : null);
					if (!((Object)(object)val3 == (Object)null))
					{
						pos = val3.position;
						yaw = val3.eulerAngles.y;
						if (((Vector3)(ref pos)).sqrMagnitude > 0.01f)
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static void DropOneWeapon()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			Server instance = Server.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Vector3 val = PickDropLand();
			if (((Vector3)(ref val)).sqrMagnitude < 0.01f)
			{
				val = DropOrigin();
			}
			Vector3 val2 = val + Vector3.up * Random.Range(11f, 16f);
			Quaternion val3 = Quaternion.Euler(Random.Range(0f, 360f), Random.Range(0f, 360f), Random.Range(0f, 360f));
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			Item val4 = null;
			if (_customsThisRound < 1 && (NeedCustomPity() || Random.value < 0.022f))
			{
				switch (Random.Range(0, 3))
				{
				case 0:
					flag = true;
					val4 = PvpBoom.PistolPrefab();
					break;
				case 1:
					flag2 = true;
					val4 = PvpSpike.RiflePrefab();
					break;
				default:
					flag3 = true;
					val4 = PvpCloak.KnifePrefab();
					break;
				}
			}
			if ((Object)(object)val4 == (Object)null)
			{
				flag = false;
				flag2 = false;
				flag3 = false;
				val4 = NextDropPrefab();
			}
			if ((Object)(object)val4 == (Object)null)
			{
				return;
			}
			Item val5 = Object.Instantiate<Item>(val4, val2, val3);
			if (!((Object)(object)val5 == (Object)null))
			{
				((Component)val5).transform.SetParent((Transform)null, true);
				((Component)val5).transform.position = val2;
				((NetworkBehaviour)instance).Spawn(((Component)val5).gameObject, (NetworkConnection)null, default(Scene));
				((Component)val5).transform.position = val2;
				if (flag)
				{
					PvpBoom.RegisterSpawned(val5);
					_customsThisRound++;
					_customsThisMatch++;
				}
				else if (flag2)
				{
					PvpSpike.RegisterSpawned(val5);
					_customsThisRound++;
					_customsThisMatch++;
				}
				else if (flag3)
				{
					PvpCloak.RegisterSpawned(val5);
					_customsThisRound++;
					_customsThisMatch++;
				}
				else
				{
					RollAttachments(val5);
				}
				((Component)val5).gameObject.AddComponent<SlowDrop>().HoldPos = val2;
				KickWeaponDown(val5);
			}
		}

		private static bool NeedCustomPity()
		{
			if (_customsThisMatch == 0)
			{
				return PvpSession.Round >= 16;
			}
			return false;
		}

		private static void RollAttachments(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			try
			{
				Weapon val = item.Weapon;
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)item).GetComponentInChildren<Weapon>(true);
				}
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				Attachments attachments = val.Attachments;
				if ((Object)(object)attachments == (Object)null)
				{
					return;
				}
				AttachmentInfo val2 = PickAttachInfo(AccessTools.Field(typeof(Attachments), "_sights").GetValue(attachments) as IList);
				if ((Object)(object)val2 != (Object)null && Random.value < 0.82f)
				{
					attachments.SetAttachment(val2);
				}
				AttachmentInfo val3 = PickAttachInfo(AccessTools.Field(typeof(Attachments), "_barrelAttachments").GetValue(attachments) as IList);
				if ((Object)(object)val3 != (Object)null && Random.value < 0.68f)
				{
					attachments.SetAttachment(val3);
				}
				object? value = AccessTools.Field(typeof(Attachments), "_laserSight").GetValue(attachments);
				LaserSight val4 = (LaserSight)((value is LaserSight) ? value : null);
				if ((Object)(object)val4 != (Object)null && (Object)(object)((Attachment)val4).Info != (Object)null && Random.value < 0.5f)
				{
					attachments.SetAttachment(((Attachment)val4).Info);
				}
				object? value2 = AccessTools.Field(typeof(Attachments), "_extendedMagInfo").GetValue(attachments);
				AttachmentInfo val5 = (AttachmentInfo)((value2 is AttachmentInfo) ? value2 : null);
				if ((Object)(object)val5 != (Object)null && Random.value < 0.5f)
				{
					try
					{
						attachments.SetAttachment(val5);
					}
					catch
					{
						object value3 = AccessTools.Field(typeof(Attachments), "_syncedExtendedMag").GetValue(attachments);
						if (value3 != null)
						{
							AccessTools.Property(value3.GetType(), "Value").SetValue(value3, true);
						}
					}
					try
					{
						AccessTools.Property(typeof(Weapon), "Ammo").SetValue(val, attachments.AmmoPerMag);
					}
					catch
					{
					}
				}
				if (AccessTools.Field(typeof(Attachments), "_bulletUpgrades").GetValue(attachments) is BulletUpgrade[] array && array.Length > 1 && Random.value < 0.48f)
				{
					int num = Random.Range(1, array.Length);
					for (int i = 0; i < num; i++)
					{
						attachments.UpgradeBullets();
					}
				}
			}
			catch
			{
			}
		}

		private static AttachmentInfo PickAttachInfo(IList list)
		{
			if (list == null || list.Count == 0)
			{
				return null;
			}
			List<AttachmentInfo> list2 = new List<AttachmentInfo>();
			for (int i = 0; i < list.Count; i++)
			{
				object? obj = list[i];
				Attachment val = (Attachment)((obj is Attachment) ? obj : null);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.Info == (Object)null))
				{
					list2.Add(val.Info);
				}
			}
			if (list2.Count == 0)
			{
				return null;
			}
			return list2[Random.Range(0, list2.Count)];
		}

		private static void KickWeaponDown(Item spawned)
		{
			//IL_0060: 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)
			try
			{
				if ((Object)(object)spawned.RigidbodySync != (Object)null)
				{
					spawned.RigidbodySync.SetKinematic(false);
				}
				Rigidbody rig = spawned.Rig;
				if (!((Object)(object)rig == (Object)null))
				{
					rig.isKinematic = false;
					rig.useGravity = true;
					rig.linearDamping = 0.8f;
					rig.angularDamping = 0.9f;
					rig.linearVelocity = new Vector3(0f, -3.4f, 0f);
					rig.angularVelocity = Random.insideUnitSphere * 1.4f;
				}
			}
			catch
			{
			}
		}

		private static void WipeCombatItems()
		{
			List<Item> list = new List<Item>();
			try
			{
				Dictionary<Transform, Item> items = ItemManager.Items;
				if (items != null)
				{
					foreach (KeyValuePair<Transform, Item> item in items)
					{
						if ((Object)(object)item.Value != (Object)null)
						{
							list.Add(item.Value);
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Item[] array = Object.FindObjectsOfType<Item>();
				if (array != null)
				{
					for (int i = 0; i < array.Length; i++)
					{
						if ((Object)(object)array[i] != (Object)null && !list.Contains(array[i]))
						{
							list.Add(array[i]);
						}
					}
				}
			}
			catch
			{
			}
			PvpSpike.Wipe();
			for (int j = 0; j < list.Count; j++)
			{
				Item val = list[j];
				if ((Object)(object)val == (Object)null || !IsCombatDrop(val))
				{
					continue;
				}
				try
				{
					if ((Object)(object)val.Holder != (Object)null && (Object)(object)val.Holder.Inventory != (Object)null)
					{
						val.Holder.Inventory.RemoveItem(val);
					}
				}
				catch
				{
				}
				try
				{
					val.DestroyItem((byte)0, byte.MaxValue);
				}
				catch
				{
				}
			}
		}

		private static Item NextDropPrefab()
		{
			List<Item> list = DroppablePrefabs();
			if (list == null || list.Count == 0)
			{
				return null;
			}
			if (_dropAt >= list.Count)
			{
				Shuffle(list);
				_dropAt = 0;
			}
			return list[_dropAt++];
		}

		private static void Shuffle(List<Item> list)
		{
			for (int num = list.Count - 1; num > 0; num--)
			{
				int index = Random.Range(0, num + 1);
				Item value = list[num];
				list[num] = list[index];
				list[index] = value;
			}
		}

		private static List<Item> DroppablePrefabs()
		{
			if (_dropPrefabs != null && _dropPrefabs.Count > 0)
			{
				return _dropPrefabs;
			}
			Dictionary<byte, Item> dictionary = new Dictionary<byte, Item>();
			Dictionary<string, Item> dictionary2 = new Dictionary<string, Item>();
			try
			{
				if (AccessTools.Field(typeof(GameInfo), "_nameToSpawnable").GetValue(null) is Dictionary<string, Item> dictionary3)
				{
					foreach (KeyValuePair<string, Item> item in dictionary3)
					{
						ConsiderDrop(item.Value, dictionary, dictionary2);
					}
				}
			}
			catch
			{
			}
			try
			{
				if (AccessTools.Field(typeof(GameInfo), "_allItems").GetValue(null) is Dictionary<byte, Item> dictionary4)
				{
					foreach (KeyValuePair<byte, Item> item2 in dictionary4)
					{
						ConsiderDrop(item2.Value, dictionary, dictionary2);
					}
				}
			}
			catch
			{
			}
			try
			{
				Item[] array = Resources.LoadAll<Item>("");
				if (array != null)
				{
					for (int i = 0; i < array.Length; i++)
					{
						ConsiderDrop(array[i], dictionary, dictionary2);
					}
				}
			}
			catch
			{
			}
			try
			{
				ItemPurchasable[] array2 = Object.FindObjectsOfType<ItemPurchasable>(true);
				if (array2 != null)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(ItemPurchasable), "_itemToPurchase");
					for (int j = 0; j < array2.Length; j++)
					{
						if (!((Object)(object)array2[j] == (Object)null) && !(fieldInfo == null))
						{
							object? value = fieldInfo.GetValue(array2[j]);
							ConsiderDrop((Item)((value is Item) ? value : null), dictionary, dictionary2);
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Item[] array3 = Resources.FindObjectsOfTypeAll<Item>();
				if (array3 != null)
				{
					for (int k = 0; k < array3.Length; k++)
					{
						ConsiderDrop(array3[k], dictionary, dictionary2);
					}
				}
			}
			catch
			{
			}
			string[] fallbackWeapons = FallbackWeapons;
			foreach (string text in fallbackWeapons)
			{
				try
				{
					ConsiderDrop(GameInfo.GetSpawnable(text), dictionary, dictionary2);
				}
				catch
				{
				}
			}
			List<Item> list = new List<Item>();
			foreach (KeyValuePair<byte, Item> item3 in dictionary)
			{
				list.Add(item3.Value);
			}
			foreach (KeyValuePair<string, Item> item4 in dictionary2)
			{
				bool flag = false;
				for (int m = 0; m < list.Count; m++)
				{
					if ((Object)(object)list[m] == (Object)(object)item4.Value)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					list.Add(item4.Value);
				}
			}
			Shuffle(list);
			_dropPrefabs = list;
			_dropAt = 0;
			StringBuilder stringBuilder = new StringBuilder();
			for (int n = 0; n < list.Count; n++)
			{
				if (n > 0)
				{
					stringBuilder.Append(", ");
				}
				stringBuilder.Append(((Object)(object)list[n] != (Object)null) ? ((Object)list[n]).name : "?");
			}
			Debug.Log((object)("[HowToFishPvp] Combat drops: " + list.Count + " [" + stringBuilder?.ToString() + "]"));
			return list;
		}

		private static void ConsiderDrop(Item item, Dictionary<byte, Item> byId, Dictionary<string, Item> byName)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null || !IsCombatDrop(item))
			{
				return;
			}
			try
			{
				Scene scene = ((Component)item).gameObject.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					scene = ((Component)item).gameObject.scene;
					if (((Scene)(ref scene)).isLoaded)
					{
						return;
					}
				}
			}
			catch
			{
			}
			try
			{
				byte iD = item.ID;
				if (iD != 0)
				{
					byId[iD] = item;
					return;
				}
			}
			catch
			{
			}
			string text = ((Object)item).name.Replace(" ", "").ToLowerInvariant();
			if (!string.IsNullOrEmpty(text))
			{
				byName[text] = item;
			}
		}

		private static bool IsCombatDrop(Item item)
		{
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Invalid comparison between Unknown and I4
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			try
			{
				if (item.IsQuestItem)
				{
					return false;
				}
				if ((Object)(object)item.Fish != (Object)null || (Object)(object)item.Bird != (Object)null || (Object)(object)item.Creature != (Object)null || (Object)(object)item.DeadPlayer != (Object)null)
				{
					return false;
				}
				if ((Object)(object)item.FishingRod != (Object)null)
				{
					return false;
				}
				string text = ((Object)item).name.ToLowerInvariant();
				if (text.IndexOf("bait") >= 0 || text.IndexOf("hook") >= 0 || text.IndexOf("attachment") >= 0)
				{
					return false;
				}
				if (text.IndexOf("ammo") >= 0 || text.IndexOf("skin") >= 0)
				{
					return false;
				}
				if (text.IndexOf("packed") >= 0 || text.IndexOf("backup") >= 0)
				{
					return false;
				}
				if ((Object)(object)item.Weapon != (Object)null || (Object)(object)item.Melee != (Object)null || (Object)(object)item.Explosive != (Object)null)
				{
					return true;
				}
				if ((Object)(object)((Component)item).GetComponentInChildren<Weapon>(true) != (Object)null)
				{
					return true;
				}
				if ((Object)(object)((Component)item).GetComponentInChildren<Melee>(true) != (Object)null)
				{
					return true;
				}
				if ((Object)(object)((Component)item).GetComponentInChildren<Explosive>(true) != (Object)null)
				{
					return true;
				}
				if ((int)item.Type == 2)
				{
					return true;
				}
				if (text.IndexOf("pistol") >= 0 || text.IndexOf("rifle") >= 0 || text.IndexOf("shotgun") >= 0)
				{
					return true;
				}
				if (text.IndexOf("sniper") >= 0 || text.IndexOf("smg") >= 0 || text.IndexOf("revolver") >= 0)
				{
					return true;
				}
				if (text.IndexOf("knife") >= 0 || text.IndexOf("dynamite") >= 0 || text.IndexOf("grenade") >= 0)
				{
					return true;
				}
				if (text.IndexOf("knuckle") >= 0 || text.IndexOf("crossbow") >= 0)
				{
					return true;
				}
				return false;
			}
			catch
			{
				return false;
			}
		}

		internal static void GoToIsland(byte island)
		{
			byte b = CurrentIsland();
			UnlockAllIslands();
			try
			{
				ServerSaveObject curServerSave = SaveManager.CurServerSave;
				if (curServerSave != null)
				{
					curServerSave.SpawnedIsland = island;
				}
			}
			catch
			{
			}
			OnlineIslandManager.ToggleTeleportPlayers(true);
			if ((Object)(object)OnlineIslandManager.Instance != (Object)null && ((NetworkBehaviour)OnlineIslandManager.Instance).IsServerInitialized)
			{
				OnlineIslandManager.Instance.SpawnIsland(island);
			}
			IslandManager.LoadIsland(island);
			IslandManager.OnIslandChange(island);
			Debug.Log((object)("[HowToFishPvp] GoToIsland " + island + " from " + b));
		}

		private static byte CurrentIsland()
		{
			try
			{
				if ((Object)(object)OnlineIslandManager.Instance != (Object)null)
				{
					return OnlineIslandManager.CurIsland;
				}
			}
			catch
			{
			}
			return byte.MaxValue;
		}

		internal static void HideShops()
		{
			if (!PvpSession.Queued)
			{
				return;
			}
			HideNpcsAndGambling();
			HideBoatsAndRadios();
			try
			{
				Purchasable[] array = Object.FindObjectsOfType<Purchasable>();
				if (array == null)
				{
					return;
				}
				foreach (Purchasable val in array)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					try
					{
						((Interactable)val).ToggleIsInteractable(false);
					}
					catch
					{
					}
					if (AccessTools.Field(typeof(Interactable), "_modelsToOutline").GetValue(val) is GameObject[] array2)
					{
						for (int j = 0; j < array2.Length; j++)
						{
							if ((Object)(object)array2[j] != (Object)null)
							{
								array2[j].SetActive(false);
							}
						}
					}
					if (((Component)val).gameObject.activeSelf)
					{
						((Component)val).gameObject.SetActive(false);
					}
				}
			}
			catch
			{
			}
		}

		private static void HideBoatsAndRadios()
		{
			try
			{
				Boat boat = BoatManager.Boat;
				if ((Object)(object)boat != (Object)null && !PvpBoats.Keep(boat))
				{
					HideGo(((Component)boat).gameObject);
				}
			}
			catch
			{
			}
			try
			{
				Boat[] array = Object.FindObjectsOfType<Boat>();
				if (array != null)
				{
					for (int i = 0; i < array.Length; i++)
					{
						if ((Object)(object)array[i] != (Object)null && !PvpBoats.Keep(array[i]))
						{
							HideGo(((Component)array[i]).gameObject);
						}
					}
				}
				Component[] found = (Component[])(object)Object.FindObjectsOfType<SelfDrivingBoat>();
				HideComponents(found);
				BoatInteractable[] array2 = Object.FindObjectsOfType<BoatInteractable>();
				if (array2 != null)
				{
					for (int j = 0; j < array2.Length; j++)
					{
						if ((Object)(object)array2[j] != (Object)null && !PvpBoats.KeepGo(((Component)array2[j]).gameObject))
						{
							HideGo(((Component)array2[j]).gameObject);
						}
					}
				}
				BoatTrigger[] array3 = Object.FindObjectsOfType<BoatTrigger>();
				if (array3 != null)
				{
					for (int k = 0; k < array3.Length; k++)
					{
						if ((Object)(object)array3[k] != (Object)null && !PvpBoats.KeepGo(((Component)array3[k]).gameObject))
						{
							HideGo(((Component)array3[k]).gameObject);
						}
					}
				}
			}
			catch
			{
			}
			Radio[] array4 = null;
			try
			{
				array4 = Object.FindObjectsOfType<Radio>();
			}
			catch
			{
			}
			if (array4 == null)
			{
				return;
			}
			bool flag = false;
			try
			{
				flag = IsHost();
			}
			catch
			{
			}
			foreach (Radio val in array4)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Item val2 = null;
				try
				{
					val2 = ((Component)val).GetComponent<Item>();
					if ((Object)(object)val2 == (Object)null)
					{
						val2 = ((Component)val).GetComponentInParent<Item>();
					}
				}
				catch
				{
				}
				if (flag && (Object)(object)val2 != (Object)null)
				{
					try
					{
						if ((Object)(object)val2.Holder != (Object)null && (Object)(object)val2.Holder.Inventory != (Object)null)
						{
							val2.Holder.Inventory.RemoveItem(val2);
						}
					}
					catch
					{
					}
					try
					{
						val2.DestroyItem((byte)0, byte.MaxValue);
					}
					catch
					{
					}
				}
				HideGo(((Component)val).gameObject);
				if ((Object)(object)val2 != (Object)null)
				{
					HideGo(((Component)val2).gameObject);
				}
			}
		}

		private static void HideGo(GameObject go)
		{
			if (!((Object)(object)go == (Object)null) && go.activeSelf)
			{
				go.SetActive(false);
			}
		}

		private static void HideNpcsAndGambling()
		{
			try
			{
				Component[] found = (Component[])(object)Object.FindObjectsOfType<NPC>();
				HideComponents(found);
				found = (Component[])(object)Object.FindObjectsOfType<NPCInteractable>();
				HideComponents(found);
				found = (Component[])(object)Object.FindObjectsOfType<QuestInteractable>();
				HideComponents(found);
				found = (Component[])(object)Object.FindObjectsOfType<SlotMachine>();
				HideComponents(found);
				found = (Component[])(object)Object.FindObjectsOfType<CasinoBox>();
				HideComponents(found);
				found = (Component[])(object)Object.FindObjectsOfType<LocalCasino>();
				HideComponents(found);
				found = (Component[])(object)Object.FindObjectsOfType<BetButton>();
				HideComponents(found);
			}
			catch
			{
			}
		}

		private static void HideComponents(Component[] found)
		{
			if (found == null)
			{
				return;
			}
			foreach (Component val in found)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					Interactable val2 = (Interactable)(object)((val is Interactable) ? val : null);
					if ((Object)(object)val2 == (Object)null)
					{
						val2 = val.GetComponent<Interactable>();
					}
					if ((Object)(object)val2 != (Object)null)
					{
						val2.ToggleIsInteractable(false);
					}
				}
				catch
				{
				}
				if (val.gameObject.activeSelf)
				{
					val.gameObject.SetActive(false);
				}
			}
		}

		internal static void UnlockAllIslands()
		{
			if ((Object)(object)OnlineIslandManager.Instance != (Object)null)
			{
				OnlineIslandManager.Instance.UnlockIsland(byte.MaxValue);
			}
			ServerSaveObject curServerSave = SaveManager.CurServerSave;
			if (curServerSave != null)
			{
				curServerSave.MaxIsland = byte.MaxValue;
			}
		}

		private static int PickPvpIsland(int round)
		{
			if (PvpArena.NeedsSkyArena(round))
			{
				_lastIsland = 1;
				PvpSession.IslandIndex = 1;
				return 1;
			}
			int num = CurrentIsland();
			if (num == 255)
			{
				num = 1;
			}
			if (_lastIsland < 0)
			{
				_lastIsland = num;
			}
			List<int> list = PvpIslandPool();
			List<int> list2 = new List<int>();
			for (int i = 0; i < list.Count; i++)
			{
				int num2 = list[i];
				if (num2 != num && num2 != _lastIsland)
				{
					list2.Add(num2);
				}
			}
			if (list2.Count == 0)
			{
				for (int j = 0; j < list.Count; j++)
				{
					if (list[j] != num)
					{
						list2.Add(list[j]);
					}
				}
			}
			if (list2.Count == 0)
			{
				list2.AddRange(list);
			}
			if (list2.Count == 0)
			{
				list2.Add((num != 1) ? 1 : 2);
			}
			int result = (PvpSession.IslandIndex = (_lastIsland = list2[Random.Range(0, list2.Count)]));
			Debug.Log((object)("[HowToFishPvp] Pick island " + result + " (was " + num + ")"));
			return result;
		}

		private static Vector3 DropCenter(int islandIndex)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (TryGetLiveSpawn(out var pos, out var _))
			{
				return pos + Vector3.up;
			}
			return IslandCenter(islandIndex) + Vector3.up;
		}

		private static List<int> PvpIslandPool()
		{
			int num = IslandManager.TotalIslands;
			if (num < 2)
			{
				num = IslandCount();
			}
			if (num < 2)
			{
				num = 5;
			}
			List<int> list = new List<int>();
			for (int i = 1; i < num; i++)
			{
				list.Add(i);
			}
			if (list.Count == 0)
			{
				list.Add(1);
			}
			return list;
		}

		private static Vector3 IslandCenter(int index)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				IslandInfo islandInfo = IslandManager.GetIslandInfo(index);
				if (islandInfo != null)
				{
					return islandInfo.IslandPosition;
				}
			}
			catch
			{
			}
			if ((Object)(object)Player.LocalPlayer != (Object)null)
			{
				return ((Component)Player.LocalPlayer).transform.position;
			}
			return Vector3.zero;
		}

		private static int IslandCount()
		{
			try
			{
				object value = AccessTools.Field(typeof(IslandManager), "_instance").GetValue(null);
				if (value == null)
				{
					return 0;
				}
				return (AccessTools.Field(typeof(IslandManager), "_islandInfos").GetValue(value) is IslandInfo[] array) ? array.Length : 0;
			}
			catch
			{
				return 0;
			}
		}

		private static List<Player> SnapshotPlayers()
		{
			List<Player> list = new List<Player>();
			if (PlayerManager.Players == null)
			{
				return list;
			}
			foreach (Player player in PlayerManager.Players)
			{
				if ((Object)(object)player != (Object)null)
				{
					list.Add(player);
				}
			}
			list.Sort(ComparePlayers);
			return list;
		}

		private static int ComparePlayers(Player a, Player b)
		{
			string strA = (((Object)(object)a != (Object)null) ? a.SteamName : "");
			string strB = (((Object)(object)b != (Object)null) ? b.SteamName : "");
			return string.CompareOrdinal(strA, strB);
		}

		private static int PlayerCount()
		{
			if (PlayerManager.Players != null)
			{
				return PlayerManager.Players.Count;
			}
			return 0;
		}

		private static int AliveCount()
		{
			if (PlayerManager.AlivePlayers != null)
			{
				return PlayerManager.AlivePlayers.Count;
			}
			return 0;
		}

		private static Player LastAliveOrHealthiest()
		{
			if (PlayerManager.AlivePlayers != null && PlayerManager.AlivePlayers.Count == 1)
			{
				return PlayerManager.AlivePlayers[0];
			}
			Player result = null;
			int num = -1;
			foreach (Player item in SnapshotPlayers())
			{
				if (!((Object)(object)item == (Object)null) && !((Object)(object)item.Vitals == (Object)null) && item.Vitals.Health > num)
				{
					num = item.Vitals.Health;
					result = item;
				}
			}
			if (num <= 0)
			{
				return null;
			}
			return result;
		}

		private static string WinnerName()
		{
			int num = -1;
			string value = "Nobody";
			foreach (KeyValuePair<string, int> score in PvpSession.Scores)
			{
				if (score.Value > num)
				{
					num = score.Value;
					PvpSession.Names.TryGetValue(score.Key, out value);
				}
			}
			if (!string.IsNullOrEmpty(value))
			{
				return value;
			}
			return "Nobody";
		}

		private static Player HighestScorePlayer()
		{
			int num = -1;
			string text = null;
			foreach (KeyValuePair<string, int> score in PvpSession.Scores)
			{
				if (score.Value > num)
				{
					num = score.Value;
					text = score.Key;
				}
			}
			if (string.IsNullOrEmpty(text) || PlayerManager.Players == null)
			{
				return LastAliveOrHealthiest();
			}
			foreach (Player item in SnapshotPlayers())
			{
				if ((Object)(object)item != (Object)null && PvpSession.Key(item) == text)
				{
					return item;
				}
			}
			return LastAliveOrHealthiest();
		}

		private static void Announce(string message)
		{
			PvpSync.Send(message);
			Debug.Log((object)("[HowToFishPvp] " + message));
		}

		private static bool IsHost()
		{
			if ((Object)(object)Server.Instance != (Object)null)
			{
				return ((NetworkBehaviour)Server.Instance).IsServerInitialized;
			}
			return false;
		}
	}
	internal sealed class SlowDrop : MonoBehaviour
	{
		public Vector3 HoldPos;

		private Rigidbody _rig;

		private float _until;

		private float _snapUntil;

		private void Awake()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			_rig = ((Component)this).GetComponent<Rigidbody>();
			_until = Time.time + 10f;
			_snapUntil = Time.time + 0.5f;
			if (((Vector3)(ref HoldPos)).sqrMagnitude < 0.01f)
			{
				HoldPos = ((Component)this).transform.position;
			}
		}

		private void Start()
		{
			Pin();
		}

		private void FixedUpdate()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (Time.time > _until)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			if (Time.time < _snapUntil)
			{
				Pin();
			}
			if ((Object)(object)_rig == (Object)null)
			{
				_rig = ((Component)this).GetComponent<Rigidbody>();
			}
			if (!((Object)(object)_rig == (Object)null) && !_rig.isKinematic)
			{
				Vector3 linearVelocity = _rig.linearVelocity;
				if (linearVelocity.y < -3.2f)
				{
					linearVelocity.y = -3.2f;
					_rig.linearVelocity = linearVelocity;
				}
			}
		}

		private void Pin()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			if (((Vector3)(ref HoldPos)).sqrMagnitude < 0.01f)
			{
				return;
			}
			Vector3 val = ((Component)this).transform.position - HoldPos;
			if (!(((Vector3)(ref val)).sqrMagnitude < 4f))
			{
				((Component)this).transform.position = HoldPos;
				if ((Object)(object)_rig == (Object)null)
				{
					_rig = ((Component)this).GetComponent<Rigidbody>();
				}
				if ((Object)(object)_rig != (Object)null)
				{
					_rig.position = HoldPos;
					_rig.linearVelocity = new Vector3(0f, -3.4f, 0f);
				}
			}
		}
	}
	internal static class PvpFlood
	{
		public const float WarnAfter = 55f;

		public const float WarnSecs = 3.5f;

		public const float RiseSpeed = 0.5f;

		public const float MaxRise = 18f;

		private static float _baseY;

		private static float _offset;

		private static bool _held;

		private static int _lastState = -1;

		private static readonly List<Transform> _visuals = new List<Transform>();

		internal static void BeginRound()
		{
			Restore();
			Capture();
			PvpSession.FloodState = 0;
			if (PvpSession.Phase != PvpPhase.MatchOver)
			{
				PvpSession.CenterBanner = "";
			}
		}

		internal static void EndRound()
		{
			Restore();
			PvpSession.FloodState = 0;
			if (PvpSession.Phase != PvpPhase.MatchOver)
			{
				PvpSession.CenterBanner = "";
			}
		}

		internal static void Tick()
		{
			if (!PvpSession.Queued)
			{
				Restore();
				return;
			}
			if (PvpController.HostNow() && PvpSession.MatchRunning && PvpSession.Phase == PvpPhase.Fighting)
			{
				float num = Time.time - PvpSession.FightStartedAt;
				int num2 = 0;
				if (num >= 58.5f)
				{
					num2 = 2;
				}
				else if (num >= 55f)
				{
					num2 = 1;
				}
				if (num2 != PvpSession.FloodState)
				{
					PvpSession.FloodState = num2;
					switch (num2)
					{
					case 1:
						PvpSession.CenterBanner = "WATER WILL RISE";
						PvpSync.Send("floodwarn");
						break;
					case 2:
						PvpSession.CenterBanner = "";
						PvpSync.Send("floodrise");
						break;
					}
				}
			}
			Apply(PvpSession.FloodState);
		}

		private static void Apply(int state)
		{
			if (state != _lastState)
			{
				_lastState = state;
				switch (state)
				{
				case 1:
					PvpSession.CenterBanner = "WATER WILL RISE";
					break;
				case 2:
					if (PvpSession.CenterBanner == "WATER WILL RISE")
					{
						PvpSession.CenterBanner = "";
					}
					break;
				}
			}
			switch (state)
			{
			case 2:
				if (!_held)
				{
					Capture();
				}
				_offset = Mathf.Min(18f, _offset + 0.5f * Time.deltaTime);
				SetHeight(_baseY + _offset);
				break;
			case 0:
				if (_offset > 0.01f)
				{
					Restore();
				}
				break;
			}
		}

		private static void Capture()
		{
			_baseY = ReadLevel();
			_offset = 0f;
			_held = true;
			CollectVisuals();
		}

		internal static void Restore()
		{
			if (_held)
			{
				SetHeight(_baseY);
			}
			_offset = 0f;
			_held = false;
			_lastState = -1;
			_visuals.Clear();
		}

		internal static void SnapVisual()
		{
			if (_held && PvpSession.FloodState == 2)
			{
				SetHeight(_baseY + _offset);
			}
		}

		private static void SetHeight(float y)
		{
			//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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			WriteLevel(y);
			object obj = Manager();
			if (obj != null)
			{
				try
				{
					AccessTools.Method(typeof(WaterManager), "SnapAllWaterTiles", (Type[])null, (Type[])null).Invoke(obj, null);
				}
				catch
				{
				}
			}
			if (_visuals.Count == 0)
			{
				CollectVisuals();
			}
			for (int i = 0; i < _visuals.Count; i++)
			{
				Transform val = _visuals[i];
				if (!((Object)(object)val == (Object)null))
				{
					Vector3 position = val.position;
					if (!(Mathf.Abs(position.y - y) < 0.001f))
					{
						position.y = y;
						val.position = position;
					}
				}
			}
		}

		private static void CollectVisuals()
		{
			_visuals.Clear();
			HashSet<Transform> seen = new HashSet<Transform>();
			object obj = Manager();
			if (obj != null)
			{
				AddRenderers(Field(obj, "_waterTiles") as Renderer[], seen);
			}
			AddChildRenderers(MainWater(), seen);
			AddChildRenderers((obj != null) ? Xf(obj, "_waterHolder") : null, seen);
		}

		private static void AddRenderers(Renderer[] tiles, HashSet<Transform> seen)
		{
			if (tiles == null)
			{
				return;
			}
			for (int i = 0; i < tiles.Length; i++)
			{
				if ((Object)(object)tiles[i] != (Object)null)
				{
					AddXf(((Component)tiles[i]).transform, seen);
				}
			}
		}

		private static void AddChildRenderers(Transform root, HashSet<Transform> seen)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			if (componentsInChildren == null)
			{
				return;
			}
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if ((Object)(object)componentsInChildren[i] != (Object)null)
				{
					AddXf(((Component)componentsInChildren[i]).transform, seen);
				}
			}
		}

		private static void AddXf(Transform t, HashSet<Transform> seen)
		{
			if (!((Object)(object)t == (Object)null) && seen.Add(t))
			{
				_visuals.Add(t);
			}
		}

		private static float ReadLevel()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (AccessTools.Field(typeof(WaterManager), "_waterLevel").GetValue(null) is float result)
				{
					return result;
				}
			}
			catch
			{
			}
			try
			{
				return WaterManager.WaterHeight;
			}
			catch
			{
			}
			Transform val = MainWater();
			if (!((Object)(object)val != (Object)null))
			{
				return 0f;
			}
			return val.position.y;
		}

		private static void WriteLevel(float y)
		{
			try
			{
				AccessTools.Field(typeof(WaterManager), "_waterLevel").SetValue(null, y);
			}
			catch
			{
			}
		}

		private static object Manager()
		{
			try
			{
				return AccessTools.Field(typeof(WaterManager), "_instance").GetValue(null);
			}
			catch
			{
				return null;
			}
		}

		private static object Field(object wm, string name)
		{
			try
			{
				return AccessTools.Field(typeof(WaterManager), name).GetValue(wm);
			}
			catch
			{
				return null;
			}
		}

		private static Transform Xf(object wm, string name)
		{
			object obj = Field(wm, name);
			return (Transform)((obj is Transform) ? obj : null);
		}

		private static Transform MainWater()
		{
			object obj = Manager();
			if (obj == null)
			{
				return null;
			}
			return Xf(obj, "_mainWater");
		}
	}
	[HarmonyPatch]
	internal static class PvpFloodPatch
	{
		[HarmonyPatch(typeof(WaterManager), "LateUpdate")]
		[HarmonyPostfix]
		private static void AfterWater()
		{
			PvpFlood.SnapVisual();
		}
	}
	internal static class PvpWinnerCam
	{
		private static bool _on;

		internal static void Start(Player winner)
		{
			PvpSession.SpectateSteam = 0uL;
			PvpSession.CenterBanner = "WINNER";
			if ((Object)(object)winner != (Object)null)
			{
				try
				{
					PvpSession.SpectateSteam = winner.SteamID;
				}
				catch
				{
				}
				string steamName = winner.SteamName;
				if (!string.IsNullOrEmpty(steamName))
				{
					PvpSession.CenterBanner = "WINNER\n" + steamName;
				}
			}
			_on = true;
			TryEnable();
		}

		internal static void Stop()
		{
			_on = false;
			PvpSession.SpectateSteam = 0uL;
			PvpSession.CenterBanner = "";
			Player localPlayer = Player.LocalPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)localPlayer.DeathCam == (Object)null))
			{
				try
				{
					localPlayer.DeathCam.DisableDeathCam();
				}
				catch
				{
				}
				PvpController.RestoreVisuals(localPlayer);
			}
		}

		internal static void Tick()
		{
			//IL_0101: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			if (!_on && PvpSession.Phase == PvpPhase.MatchOver && PvpSession.SpectateSteam != 0L)
			{
				_on = true;
			}
			if (PvpSession.Phase != PvpPhase.MatchOver || PvpSession.SpectateSteam == 0L)
			{
				if (_on && PvpSession.Phase != PvpPhase.MatchOver)
				{
					Stop();
				}
				return;
			}
			Player val = Find(PvpSession.SpectateSteam);
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)val == (Object)null || (Object)(object)localPlayer == (Object)null || (Object)(object)localPlayer.DeathCam == (Object)null)
			{
				return;
			}
			Camera val2 = DeathCamera(localPlayer);
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			if (!((Component)val2).gameObject.activeSelf)
			{
				TryEnable();
			}
			Vector3 val3 = Body(val) + Vector3.up * 1.2f;
			Vector3 val4 = Vector3.back;
			try
			{
				if ((Object)(object)val.Transform != (Object)null)
				{
					val4 = val.Transform.forward;
					val4.y = 0f;
					if (((Vector3)(ref val4)).sqrMagnitude < 0.01f)
					{
						val4 = Vector3.back;
					}
					else
					{
						((Vector3)(ref val4)).Normalize();
					}
				}
			}
			catch
			{
			}
			Vector3 val5 = val3 - val4 * 6.4f + Vector3.up * 2.3f;
			((Component)val2).transform.position = Vector3.Lerp(((Component)val2).transform.position, val5, Time.deltaTime * 5f);
			((Component)val2).transform.LookAt(val3);
		}

		private static void TryEnable()
		{
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)localPlayer.DeathCam == (Object)null)
			{
				return;
			}
			try
			{
				localPlayer.DeathCam.EnableDeathCam();
			}
			catch
			{
			}
		}

		private static Camera DeathCamera(Player player)
		{
			try
			{
				object? value = AccessTools.Field(typeof(PlayerDeathCam), "_deathCam").GetValue(player.DeathCam);
				return (Camera)((value is Camera) ? value : null);
			}
			catch
			{
				return null;
			}
		}

		private static Vector3 Body(Player player)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)player.Transform != (Object)null)
				{
					return player.Transform.position;
				}
			}
			catch
			{
			}
			return ((Component)player).transform.position;
		}

		private static Player Find(ulong steam)
		{
			if (steam == 0L || PlayerManager.Players == null)
			{
				return null;
			}
			foreach (Player player in PlayerManager.Players)
			{
				if ((Object)(object)player == (Object)null)
				{
					continue;
				}
				try
				{
					if (player.SteamID == steam)
					{
						return player;
					}
				}
				catch
				{
				}
			}
			return null;
		}
	}
	[HarmonyPatch]
	public class PvpGrab : MonoBehaviour
	{
		private enum Kind
		{
			None,
			Player,
			World
		}

		private class GrabView
		{
			public Vector3 Point;

			public float Blend;

			public float Until;

			public bool Captured;

			public readonly Vector3[] StartPos = (Vector3[])(object)new Vector3[2];

			public readonly Quaternion[] StartRot = (Quaternion[])(object)new Quaternion[2];
		}

		private const float DefaultRange = 2.85f;

		private const float KeepRange = 4.6f;

		private const float HandSpeed = 12f;

		private static Kind _kind;

		private static Player _victim;

		private static Transform _anchor;

		private static Vector3 _localPoint;

		private static Vector3 _localNormal;

		private static Vector3 _localBody;

		private static float _reach;

		private static GrabView _mine;

		private static readonly Dictionary<int, GrabView> _seen = new Dictionary<int, GrabView>();

		private static readonly List<int> _drop = new List<int>();

		private static float _nextRpc;

		private static float _nextSend;

		private static bool _toldHost;

		private static ulong _remoteSid;

		private static Vector3 _remoteDest;

		private static float _remoteUntil;

		internal static bool Holding => _kind != Kind.None;

		private void Update()
		{
			TickLocal();
			TickRemote();
			TickSeen();
		}

		private void LateUpdate()
		{
			if (_kind == Kind.World)
			{
				HangSelf(physics: false);
			}
		}

		internal static void Hear(string rest)
		{
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(rest) || rest.Length < 2)
			{
				return;
			}
			if (rest[0] == 'u' && rest[1] == ' ')
			{
				int num = IndexOf(ParsePlayer(rest.Substring(2).Trim()));
				if (num >= 0)
				{
					_seen.Remove(num);
				}
			}
			else
			{
				if (rest[0] != 'a' || rest[1] != ' ')
				{
					return;
				}
				string[] array = rest.Split(new char[1] { ' ' });
				if (array.Length < 5)
				{
					return;
				}
				Player val = ParsePlayer(array[1]);
				if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)Player.LocalPlayer || !TryFloat(array[2], out var v) || !TryFloat(array[3], out var v2) || !TryFloat(array[4], out var v3))
				{
					return;
				}
				int num2 = IndexOf(val);
				if (num2 >= 0)
				{
					if (!_seen.TryGetValue(num2, out var value) || value == null)
					{
						value = new GrabView();
						_seen[num2] = value;
					}
					value.Point = new Vector3(v, v2, v3);
					value.Until = Time.unscaledTime + 0.4f;
				}
			}
		}

		internal static void HostHear(string rest)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(rest) || rest.Length < 2)
			{
				return;
			}
			if (rest[0] == 'u' && (rest.Length == 1 || rest[1] == ' '))
			{
				_remoteSid = 0uL;
			}
			else
			{
				if (rest[0] != 'g' || rest[1] != ' ')
				{
					return;
				}
				string[] array = rest.Split(new char[1] { ' ' });
				if (array.Length >= 5)
				{
					Player val = ParsePlayer(array[1]);
					if (!((Object)(object)val == (Object)null) && TryFloat(array[2], out var v) && TryFloat(array[3], out var v2) && TryFloat(array[4], out var v3))
					{
						_remoteSid = Sid(val);
						_remoteDest = new Vector3(v, v2, v3);
						_remoteUntil = Time.unscaledTime + 0.35f;
					}
				}
			}
		}

		internal static bool HideChat(string rest)
		{
			if (string.IsNullOrEmpty(rest) || rest.Length < 2)
			{
				return false;
			}
			if (rest[0] == 'g' || rest[0] == 'u' || rest[0] == 'a')
			{
				return rest[1] == ' ';
			}
			return false;
		}

		internal static void ResetPose(Player player)
		{
			ResetPose(player, full: true);
		}

		internal static void UnstickArms(Player player)
		{
			ResetPose(player, full: false);
		}

		private static void ResetPose(Player player, bool full)
		{
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			int num = IndexOf(player);
			if (num >= 0 && full)
			{
				_seen.Remove(num);
			}
			if (full && (Object)(object)player == (Object)(object)Player.LocalPlayer)
			{
				Stop(notify: true);
			}
			bool flag = PunchStuck(player);
			ClearPunch(player);
			if (full || (flag && (Object)(object)player != (Object)(object)Player.LocalPlayer))
			{
				try
				{
					if ((Object)(object)player.Body != (Object)null)
					{
						player.Body.Reset();
					}
				}
				catch
				{
				}
				try
				{
					if ((Object)(object)player.Legs != (Object)null)
					{
						player.Legs.Reset();
					}
				}
				catch
				{
				}
			}
			try
			{
				if ((Object)(object)player.Hands != (Object)null)
				{
					player.Hands.ToggleHandMeshes(true);
					MethodInfo methodInfo = AccessTools.Method(typeof(PlayerHands), "MoveHandToDefault", (Type[])null, (Type[])null);
					if (methodInfo != null)
					{
						methodInfo.Invoke(player.Hands, new object[1] { true });
						methodInfo.Invoke(player.Hands, new object[1] { false });
					}
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)player != (Object)(object)Player.LocalPlayer && (Object)(object)player.Other != (Object)null && (Object)(object)player.Transform != (Object)null)
				{
					float num2 = 0f;
					if ((Object)(object)player.CamObject != (Object)null)
					{
						num2 = player.CamObject.eulerAngles.y;
					}
					player.Other.Teleport(player.Transform.position, new Vector2(0f, num2));
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)player.Arms != (Object)null && (Object)(object)player.Hands != (Object)null)
				{
					player.Arms.SetIKTarget(player.Hands.HandBoneRight, player.Hands.HandBoneLeft);
				}
			}
			catch
			{
			}
		}

		private static void TickLocal()
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			if (!PvpSession.Queued)
			{
				Stop(notify: true);
				return;
			}
			Player localPlayer = Player.LocalPlayer;
			if (!RightHeld() || HandsFull(localPlayer) || Dead(localPlayer) || (Object)(object)localPlayer == (Object)null || localPlayer.BlockInputs)
			{
				Stop(notify: true);
				return;
			}
			if (_kind == Kind.None)
			{
				TryBegin();
			}
			if (_kind == Kind.None || _mine == null)
			{
				return;
			}
			if ((Object)(object)_anchor == (Object)null)
			{
				Stop(notify: true);
				return;
			}
			_mine.Blend = Mathf.MoveTowards(_mine.Blend, 1f, Time.deltaTime * 12f);
			Vector3 val = WorldGrab();
			_mine.Point = val;
			Vector3 val2 = val - AimOrigin(localPlayer);
			if (((Vector3)(ref val2)).sqrMagnitude > 21.16f)
			{
				Stop(notify: true);
			}
			else if (_kind == Kind.Player)
			{
				if ((Object)(object)_victim == (Object)null || Dead(_victim))
				{
					Stop(notify: true);
					return;
				}
				Vector3 val3 = HoldInFront(localPlayer) - val;
				Vector3 dest = Body(_victim) + val3;
				DragVictim(_victim, dest);
				MaybeSend(val, dest, drag: true);
			}
			else
			{
				HangSelf(physics: true);
				MaybeSend(val, Vector3.zero, drag: false);
			}
		}

		private static void TickRemote()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (IsHost() && _remoteSid != 0L && !(Time.unscaledTime > _remoteUntil))
			{
				Player val = BySid(_remoteSid);
				if (!((Object)(object)val == (Object)null) && !Dead(val) && (_kind != Kind.Player || !((Object)(object)val == (Object)(object)_victim)))
				{
					DragVictim(val, _remoteDest);
				}
			}
		}

		private static void TickSeen()
		{
			_drop.Clear();
			foreach (KeyValuePair<int, GrabView> item in _seen)
			{
				GrabView value = item.Value;
				if (value == null || Time.unscaledTime > value.Until)
				{
					_drop.Add(item.Key);
				}
				else
				{
					value.Blend = Mathf.MoveTowards(value.Blend, 1f, Time.deltaTime * 12f);
				}
			}
			for (int i = 0; i < _drop.Count; i++)
			{
				_seen.Remove(_drop[i]);
			}
		}

		private static bool TryBegin()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: 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)
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)localPlayer.CamObject == (Object)null)
			{
				return false;
			}
			if (!AimHit(localPlayer, out var best, out var other))
			{
				return false;
			}
			_anchor = ((RaycastHit)(ref best)).transform;
			_localPoint = _anchor.InverseTransformPoint(((RaycastHit)(ref best)).point);
			Transform anchor = _anchor;
			Vector3 normal = ((RaycastHit)(ref best)).normal;
			_localNormal = anchor.InverseTransformDirection((((Vector3)(ref normal)).sqrMagnitude > 0.01f) ? ((RaycastHit)(ref best)).normal : (-AimFwd(localPlayer)));
			_reach = Mathf.Clamp(((RaycastHit)(ref best)).distance, 0.45f, PunchRange(localPlayer));
			_mine = new GrabView();
			Rigidbody val = Rig(localPlayer);
			Vector3 val2 = (((Object)(object)val != (Object)null) ? val.position : Body(localPlayer));
			_localBody = _anchor.InverseTransformPoint(val2);
			if ((Object)(object)other != (Object)null && (Object)(object)other != (Object)(object)localPlayer && !Dead(other))
			{
				_kind = Kind.Player;
				_victim = other;
			}
			else
			{
				_kind = Kind.World;
				_victim = null;
			}
			return true;
		}

		private static void Stop(bool notify)
		{
			if (_kind == Kind.None && _mine == null)
			{
				return;
			}
			_kind = Kind.None;
			_victim = null;
			_anchor = null;
			_mine = null;
			if (notify)
			{
				ulong num = Sid(Player.LocalPlayer);
				if (num != 0L && _toldHost)
				{
					PvpSync.Send("u " + num);
				}
				PvpSync.SetMemberGrab("", "");
			}
			_toldHost = false;
		}

		private static bool AimHit(Player me, out RaycastHit best, out Player other)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			best = default(RaycastHit);
			other = null;
			Transform camObject = me.CamObject;
			Vector3 position = camObject.position;
			Vector3 forward = camObject.forward;
			float num = PunchRange(me);
			int num2 = Mask();
			RaycastHit[] array = Physics.RaycastAll(position, forward, num, num2, (QueryTriggerInteraction)1);
			if (array == null || array.Length == 0)
			{
				array = Physics.RaycastAll(position, forward, num, -5, (QueryTriggerInteraction)1);
			}
			float num3 = num + 0.01f;
			bool result = false;
			if (array == null)
			{
				return false;
			}
			for (int i = 0; i < array.Length; i++)
			{
				RaycastHit val = array[i];
				if (!((Object)(object)((RaycastHit)(ref val)).collider == (Object)null) && !(((RaycastHit)(ref val)).distance < 0.08f) && !(((RaycastHit)(ref val)).distance > num3))
				{
					Player val2 = null;
					try
					{
						val2 = PlayerManager.GetPlayerFromBodyPart(((RaycastHit)(ref val)).transform);
					}
					catch
					{
					}
					if (!((Object)(object)val2 == (Object)(object)me))
					{
						num3 = ((RaycastHit)(ref val)).distance;
						best = val;
						other = val2;
						result = true;
					}
				}
			}
			return result;
		}

		private static int Mask()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			LayerMask val;
			try
			{
				int num2 = num;
				val = GameInfo.LevelLayer;
				num = num2 | ((LayerMask)(ref val)).value;
			}
			catch
			{
			}
			try
			{
				int num3 = num;
				val = GameInfo.PlayerLayers;
				num = num3 | ((LayerMask)(ref val)).value;
			}
			catch
			{
			}
			try
			{
				int num4 = num;
				val = GameInfo.CanJumpOnLayers;
				num = num4 | ((LayerMask)(ref val)).value;
			}
			catch
			{
			}
			try
			{
				int num5 = num;
				val = GameInfo.BoatLayer;
				num = num5 | ((LayerMask)(ref val)).value;
			}
			catch
			{
			}
			if (num == 0)
			{
				num = -5;
			}
			return num;
		}

		private static float PunchRange(Player me)
		{
			try
			{
				if ((Object)(object)me != (Object)null && (Object)(object)me.Punching != (Object)null && AccessTools.Field(typeof(PlayerPunching), "_range").GetValue(me.Punching) is float num && num > 0.4f && num < 8f)
				{
					return num;
				}
			}
			catch
			{
			}
			return 2.85f;
		}

		private static Vector3 WorldGrab()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_anchor == (Object)null)
			{
				return Vector3.zero;
			}
			return _anchor.TransformPoint(_localPoint);
		}

		private static Vector3 HoldInFront(Player me)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			Transform camObject = me.CamObject;
			if ((Object)(object)camObject == (Object)null)
			{
				return Body(me) + AimFwd(me) * _reach;
			}
			return camObject.position + camObject.forward * _reach;
		}

		private static void HangSelf(bool physics)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)_anchor == (Object)null)
			{
				return;
			}
			Rigidbody val = Rig(localPlayer);
			Vector3 val2 = _anchor.TransformPoint(_localBody);
			if ((Object)(object)val != (Object)null)
			{
				Vector3 val3 = (val2 - val.position) / Mathf.Max(Time.deltaTime, 0.0001f);
				if (physics)
				{
					val.linearVelocity = Vector3.Lerp(val.linearVelocity, val3, 0.8f);
					val.position = val2;
				}
				else
				{
					val.position = val2;
				}
			}
			else if ((Object)(object)localPlayer.Transform != (Object)null)
			{
				localPlayer.Transform.position = val2;
			}
		}

		private static void DragVictim(Player victim, Vector3 dest)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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)
			//IL_0053: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)victim == (Object)null)
			{
				return;
			}
			Rigidbody val = Rig(victim);
			Vector3 val2 = (((Object)(object)val != (Object)null) ? val.position : Body(victim));
			Vector3 val3 = Vector3.Lerp(val2, dest, 1f - Mathf.Exp(-14f * Time.deltaTime));
			if ((Object)(object)val != (Object)null)
			{
				val.linearVelocity = (val3 - val2) / Mathf.Max(Time.deltaTime, 0.0001f);
				val.position = val3;
			}
			else if ((Object)(object)victim.Transform != (Object)null)
			{
				victim.Transform.position = val3;
			}
			if (IsHost() && !(Time.unscaledTime < _nextRpc))
			{
				_nextRpc = Time.unscaledTime + 0.07f;
				float num = Yaw(victim);
				try
				{
					victim.LocalTeleport(val3, num, true);
				}
				catch
				{
				}
				Server instance = Server.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.RpcLogic___TeleportPlayer___3852204532(victim, val3, num);
				}
			}
		}

		private static void MaybeSend(Vector3 grab, Vector3 dest, bool drag)
		{
			//IL_004c: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			if (Time.unscaledTime < _nextSend)
			{
				return;
			}
			_nextSend = Time.unscaledTime + 0.08f;
			ulong num = Sid(Player.LocalPlayer);
			if (num == 0L)
			{
				return;
			}
			_toldHost = true;
			string text = num + " " + F(grab.x) + " " + F(grab.y) + " " + F(grab.z);
			PvpSync.Send("a " + text);
			string text2 = "";
			if (drag && (Object)(object)_victim != (Object)null)
			{
				ulong num2 = Sid(_victim);
				if (num2 != 0L)
				{
					text2 = num2 + " " + F(dest.x) + " " + F(dest.y) + " " + F(dest.z);
				}
				if (!IsHost() && text2.Length > 0)
				{
					PvpSync.Send("g " + text2);
				}
			}
			if (!IsHost())
			{
				PvpSync.SetMemberGrab(text2, text);
			}
		}

		private static void DriveHands(PlayerHands hands, Player owner, GrabView view)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)hands == (Object)null || (Object)(object)owner == (Object)null || view == null || Dead(owner))
			{
				return;
			}
			Transform camObject = owner.CamObject;
			Transform handBoneLeft = hands.HandBoneLeft;
			Transform handBoneRight = hands.HandBoneRight;
			if (!((Object)(object)camObject == (Object)null) && !((Object)(object)handBoneLeft == (Object)null) && !((Object)(object)handBoneRight == (Object)null))
			{
				if (!view.Captured)
				{
					view.StartPos[0] = camObject.InverseTransformPoint(handBoneRight.position);
					view.StartPos[1] = camObject.InverseTransformPoint(handBoneLeft.position);
					view.StartRot[0] = handBoneRight.localRotation;
					view.StartRot[1] = handBoneLeft.localRotation;
					view.Captured = true;
				}
				Vector3 point = view.Point;
				point -= camObject.forward * PunchHitPad(owner);
				Vector3 right = camObject.right;
				float t = Mathf.SmoothStep(0f, 1f, Mathf.Clamp01(view.Blend));
				PunchFist(handBoneRight, camObject, owner, view, 0, point + right * 0.08f, t);
				PunchFist(handBoneLeft, camObject, owner, view, 1, point - right * 0.08f, t);
			}
		}

		private static void PunchFist(Transform fist, Transform cam, Player owner, GrabView view, int side, Vector3 worldHit, float t)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = cam.TransformPoint(view.StartPos[side]);
			fist.position = Vector3.Lerp(val, worldHit, t);
			Quaternion val2 = view.StartRot[side];
			Quaternion val3 = cam.rotation * Quaternion.Euler(PunchHitEuler(owner, side));
			Quaternion val4 = val3;
			if ((Object)(object)fist.parent != (Object)null)
			{
				val4 = Quaternion.Inverse(fist.parent.rotation) * val3;
			}
			fist.localRotation = Quaternion.Slerp(val2, val4, t);
		}

		private static Vector3 PunchHitEuler(Player me, int side)
		{
			//IL_0067: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)me != (Object)null && (Object)(object)me.Punching != (Object)null && AccessTools.Field(typeof(PlayerPunching), "_hitRots").GetValue(me.Punching) is Vector3[] array && side >= 0 && side < array.Length)
				{
					return array[side];
				}
			}
			catch
			{
			}
			return new Vector3(70f, 0f, 0f);
		}

		private static float PunchHitPad(Player me)
		{
			try
			{
				if ((Object)(object)me != (Object)null && (Object)(object)me.Punching != (Object)null)
				{
					object value = AccessTools.Field(typeof(PlayerPunching), "_hitOffsetDist").GetValue(me.Punching);
					if (value is float)
					{
						return (float)value;
					}
				}
			}
			catch
			{
			}
			return 0.08f;
		}

		private static bool PunchStuck(Player player)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player.Punching == (Object)null)
			{
				return false;
			}
			try
			{
				if (AnyTrue(AccessTools.Field(typeof(PlayerPunching), "_isAttacking").GetValue(player.Punching) as bool[]))
				{
					return true;
				}
				if (AnyTrue(AccessTools.Field(typeof(PlayerPunching), "_isReturning").GetValue(player.Punching) as bool[]))
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool AnyTrue(bool[] arr)
		{
			if (arr == null)
			{
				return false;
			}
			for (int i = 0; i < arr.Length; i++)
			{
				if (arr[i])
				{
					return true;
				}
			}
			return false;
		}

		private static void ClearPunch(Player player)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player.Punching == (Object)null)
			{
				return;
			}
			PlayerPunching punching = player.Punching;
			ClearBools(AccessTools.Field(typeof(PlayerPunching), "_isAttacking").GetValue(punching) as bool[]);
			ClearBools(AccessTools.Field(typeof(PlayerPunching), "_isReturning").GetValue(punching) as bool[]);
			if (AccessTools.Field(typeof(PlayerPunching), "_curAttackPercent").GetValue(punching) is float[] array)
			{
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = 0f;
				}
			}
			if (AccessTools.Field(typeof(PlayerPunching), "_curTarget").GetValue(punching) is Transform[] array2)
			{
				for (int j = 0; j < array2.Length; j++)
				{
					array2[j] = null;
				}
			}
			try
			{
				AccessTools.Field(typeof(PlayerPunching), "_queuedPunch").SetValue(punching, false);
			}
			catch
			{
			}
		}

		private static void ClearBools(bool[] arr)
		{
			if (arr != null)
			{
				for (int i = 0; i < arr.Length; i++)
				{
					arr[i] = false;
				}
			}
		}

		private static Vector3 AimOrigin(Player p)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)p != (Object)null && (Object)(object)p.CamObject != (Object)null)
			{
				return p.CamObject.position;
			}
			return Body(p) + Vector3.up * 1.4f;
		}

		private static Vector3 AimFwd(Player p)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)p != (Object)null && (Object)(object)p.CamObject != (Object)null)
			{
				return p.CamObject.forward;
			}
			if ((Object)(object)p != (Object)null && (Object)(object)p.Transform != (Object)null)
			{
				return p.Transform.forward;
			}
			return Vector3.forward;
		}

		private static Vector3 Body(Player p)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)p == (Object)null)
			{
				return Vector3.zero;
			}
			try
			{
				if ((Object)(object)p.Transform != (Object)null)
				{
					return p.Transform.position;
				}
			}
			catch
			{
			}
			return ((Component)p).transform.position;
		}

		private static float Yaw(Player p)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)p != (Object)null && (Object)(object)p.CamObject != (Object)null)
				{
					return p.CamObject.eulerAngles.y;
				}
			}
			catch
			{
			}
			return 0f;
		}

		private static bool HandsFull(Player p)
		{
			try
			{
				return (Object)(object)p != (Object)null && (Object)(object)p.Holding != (Object)null && (Object)(object)p.Holding.HeldItem != (Object)null;
			}
			catch
			{
				return true;
			}
		}

		private static bool Dead(Player p)
		{
			try
			{
				if ((Object)(object)p == (Object)null)
				{
					return true;
				}
				if ((Object)(object)p.Dying != (Object)null && p.Dying.IsDead)
				{
					return true;
				}
				if ((Object)(object)p.Vitals != (Object)null && p.Vitals.Health <= 0)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool RightHeld()
		{
			try
			{
				if (Input.GetMouseButton(1))
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private static Rigidbody Rig(Player p)
		{
			if ((Object)(object)p == (Object)null || (Object)(object)p.Movement == (Object)null)
			{
				return null;
			}
			object? value = AccessTools.Field(typeof(PlayerMovement), "_rig").GetValue(p.Movement);
			return (Rigidbody)((value is Rigidbody) ? value : null);
		}

		private static Player OwnerOf(PlayerHands hands)
		{
			object? value = AccessTools.Field(typeof(PlayerHands), "_player").GetValue(hands);
			return (Player)((value is Player) ? value : null);
		}

		private static ulong Sid(Player player)
		{
			try
			{
				if ((Object)(object)player != (Object)null)
				{
					return player.SteamID;
				}
			}
			catch
			{
			}
			return 0uL;
		}

		private static Player BySid(ulong id)
		{
			if (id == 0L || PlayerManager.Players == null)
			{
				return null;
			}
			foreach (Player player in PlayerManager.Players)
			{
				if ((Object)(object)player != (Object)null && Sid(player) == id)
				{
					return player;
				}
			}
			return null;
		}

		private static Player ParsePlayer(string token)
		{
			if (string.IsNullOrEmpty(token))
			{
				return null;
			}
			if (ulong.TryParse(token, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result > 1000)
			{
				return BySid(result);
			}
			if (int.TryParse(token, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
			{
				return PlayerAt(result2);
			}
			return null;
		}

		private static int IndexOf(Player player)
		{
			if ((Object)(object)player == (Object)null || PlayerManager.Players == null)
			{
				return -1;
			}
			int num = 0;
			foreach (Player player2 in PlayerManager.Players)
			{
				if ((Object)(object)player2 == (Object)(object)player)
				{
					return num;
				}
				num++;
			}
			return -1;
		}

		private static Player PlayerAt(int idx)
		{
			if (idx < 0 || PlayerManager.Players == null || idx >= PlayerManager.Players.Count)
			{
				return null;
			}
			return PlayerManager.Players[idx];
		}

		private static bool TryFloat(string s, out float v)
		{
			return float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out v);
		}

		private static string F(float v)
		{
			return v.ToString("F2", CultureInfo.InvariantCulture);
		}

		private static bool IsHost()
		{
			if ((Object)(object)Server.Instance != (Object)null)
			{
				return ((NetworkBehaviour)Server.Instance).IsServerInitialized;
			}
			return false;
		}

		[HarmonyPatch(typeof(PlayerHands), "LateUpdate")]
		[HarmonyPostfix]
		private static void AfterHands(PlayerHands __instance)
		{
			if (!PvpSession.Queued || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			Player val = OwnerOf(__instance);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if ((Object)(object)val == (Object)(object)Player.LocalPlayer)
			{
				if (Holding && _mine != null)
				{
					DriveHands(__instance, val, _mine);
				}
				return;
			}
			int num = IndexOf(val);
			if (num >= 0 && _seen.TryGetValue(num, out var value) && value != null && Time.unscaledTime <= value.Until)
			{
				DriveHands(__instance, val, value);
			}
		}
	}
	public class PvpHud : MonoBehaviour
	{
		private sealed class ScoreRow
		{
			public string Key;

			public GameObject Root;

			public RawImage Avatar;

			public TextMeshProUGUI Name;

			public TextMeshProUGUI Score;
		}

		private struct ScoreEntry
		{
			public string Key;

			public string Name;

			public int Score;

			public ulong SteamId;
		}

		private Canvas _canvas;

		private RectTransform _board;

		private readonly List<ScoreRow> _rows = new List<ScoreRow>();

		private TMP_FontAsset _font;

		private TextMeshProUGUI _lobbyTitle;

		private TextMeshProUGUI _lobbySub;

		private TextMeshProUGUI _countText;

		private TextMeshProUGUI _countShadow;

		private int _lastCount = -99;

		private float _countScale = 1f;

		private void LateUpdate()
		{
			PvpSync.Tick();
			if (!PvpSession.Queued && !PvpSession.MatchRunning && PvpSession.Phase != PvpPhase.MatchOver)
			{
				if ((Object)(object)_canvas != (Object)null)
				{
					((Component)_canvas).gameObject.SetActive(false);
				}
				return;
			}
			EnsureHud();
			if ((Object)(object)_canvas == (Object)null)
			{
				return;
			}
			((Component)_canvas).gameObject.SetActive(true);
			bool flag = PvpSession.Queued && !PvpSession.MatchRunning && PvpSession.Phase != PvpPhase.MatchOver;
			if ((Object)(object)_lobbyTitle != (Object)null)
			{
				((Component)_lobbyTitle).gameObject.SetActive(flag);
				if (flag)
				{
					((TMP_Text)_lobbyTitle).text = "PVP MODE";
				}
			}
			if ((Object)(object)_lobbySub != (Object)null)
			{
				((Component)_lobbySub).gameObject.SetActive(flag);
				if (flag)
				{
					bool flag2 = (Object)(object)Server.Instance != (Object)null && ((NetworkBehaviour)Server.Instance).IsServerInitialized;
					((TMP_Text)_lobbySub).text = (flag2 ? "Waiting for players... host press F8 to start" : "Waiting for host to start");
				}
			}
			if ((Object)(object)_board != (Object)null)
			{
				((Component)_board).gameObject.SetActive(!flag);
			}
			if (!flag)
			{
				RefreshScores();
			}
			UpdateCountdown();
		}

		private void RefreshScores()
		{
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			TrackAlivePlayers();
			List<ScoreEntry> list = OrderedScores();
			while (_rows.Count < list.Count)
			{
				_rows.Add(MakeRow((Transform)(object)_board, _font));
			}
			for (int i = 0; i < _rows.Count; i++)
			{
				if (i >= list.Count)
				{
					_rows[i].Root.SetActive(false);
					continue;
				}
				ScoreEntry scoreEntry = list[i];
				ScoreRow scoreRow = _rows[i];
				scoreRow.Root.SetActive(true);
				scoreRow.Key = scoreEntry.Key;
				((TMP_Text)scoreRow.Name).text = scoreEntry.Name;
				((TMP_Text)scoreRow.Score).text = scoreEntry.Score.ToString();
				Texture2D val = SteamAvatars.Get(scoreEntry.SteamId);
				if ((Object)(object)scoreRow.Avatar != (Object)null)
				{
					scoreRow.Avatar.texture = (Texture)(object)val;
					((Graphic)scoreRow.Avatar).color = (Color)(((Object)(object)val != (Object)null) ? Color.white : new Color(1f, 1f, 1f, 0.15f));
				}
			}
		}

		private static void TrackAlivePlayers()
		{
			if (PlayerManager.Players == null)
			{
				return;
			}
			foreach (Player player in PlayerManager.Players)
			{
				PvpSession.EnsurePlayer(player);
			}
		}

		private static List<ScoreEntry> OrderedScores()
		{
			List<ScoreEntry> list = new List<ScoreEntry>();
			if (PlayerManager.Players != null)
			{
				foreach (Player player in PlayerManager.Players)
				{
					if (!((Object)(object)player == (Object)null))
					{
						string text = PvpSession.Key(player);
						if (!PvpSession.Scores.TryGetValue(text, out var value))
						{
							value = 0;
						}
						list.Add(new ScoreEntry
						{
							Key = text,
							Name = (string.IsNullOrEmpty(player.SteamName) ? text : player.SteamName),
							Score = value,
							SteamId = player.SteamID
						});
					}
				}
			}
			if (list.Count == 0)
			{
				foreach (KeyValuePair<string, int> score in PvpSession.Scores)
				{
					if (!PvpSession.Names.TryGetValue(score.Key, out var value2))
					{
						value2 = score.Key;
					}
					list.Add(new ScoreEntry
					{
						Key = score.Key,
						Name = value2,
						Score = score.Value,
						SteamId = 0uL
					});
				}
			}
			list.Sort(delegate(ScoreEntry a, ScoreEntry b)
			{
				int num = b.Score.CompareTo(a.Score);
				return (num == 0) ? string.CompareOrdinal(a.Name, b.Name) : num;
			});
			return list;
		}

		private void UpdateCountdown()
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_countText == (Object)null)
			{
				return;
			}
			int num = PvpSession.CountdownDisplay;
			string text = "";
			float fontSize = 180f;
			if (!string.IsNullOrEmpty(PvpSession.CenterBanner))
			{
				text = PvpSession.CenterBanner;
				fontSize = ((PvpSession.CenterBanner.IndexOf("WINNER", StringComparison.OrdinalIgnoreCase) >= 0) ? 86f : 52f);
				num = -2;
			}
			else if (num > 0)
			{
				text = num.ToString();
			}
			else if (num == 0)
			{
				text = "GO";
			}
			if ((Object)(object)_countText != (Object)null)
			{
				((TMP_Text)_countText).fontSize = fontSize;
				((TMP_Text)_countText).textWrappingMode = (TextWrappingModes)(!string.IsNullOrEmpty(PvpSession.CenterBanner));
				((TMP_Text)_countText).rectTransform.sizeDelta = new Vector2(1400f, 320f);
			}
			if ((Object)(object)_countShadow != (Object)null)
			{
				((TMP_Text)_countShadow).fontSize = fontSize;
				((TMP_Text)_countShadow).textWrappingMode = (TextWrappingModes)(!string.IsNullOrEmpty(PvpSession.CenterBanner));
				((TMP_Text)_countShadow).rectTransform.sizeDelta = new Vector2(1400f, 320f);
			}
			if ((Object)(object)_countShadow != (Object)null)
			{
				((TMP_Text)_countShadow).text = text;
			}
			((TMP_Text)_countText).text = text;
			if (num != _lastCount)
			{
				_lastCount = num;
				_countScale = ((num == 0) ? 1.55f : 1.35f);
				if (num >= 0)
				{
					PlayCountSound(num == 0);
				}
			}
			_countScale = Mathf.Lerp(_countScale, 1f, Time.deltaTime * 8f);
			((Transform)((TMP_Text)_countText).rectTransform).localScale = Vector3.one * _countScale;
			if ((Object)(object)_countShadow != (Object)null)
			{
				((Transform)((TMP_Text)_countShadow).rectTransform).localScale = Vector3.one * _countScale;
			}
		}

		private void EnsureHud()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Expected O, but got Unknown
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_canvas != (Object)null))
			{
				_font = FindFont();
				if (!((Object)(object)_font == (Object)null))
				{
					GameObject val = new GameObject("HowToFishPvpHud");
					Object.DontDestroyOnLoad((Object)(object)val);
					_canvas = val.AddComponent<Canvas>();
					_canvas.renderMode = (RenderMode)0;
					_canvas.sortingOrder = 4000;
					CanvasScaler obj = val.AddComponent<CanvasScaler>();
					obj.uiScaleMode = (ScaleMode)1;
					obj.referenceResolution = new Vector2(1920f, 1080f);
					obj.matchWidthOrHeight = 0.5f;
					_lobbyTitle = MakeLobbyLabel(val.transform, _font, "LobbyTitle", -22f, 34f);
					_lobbySub = MakeLobbyLabel(val.transform, _font, "LobbySub", -58f, 22f);
					GameObject val2 = new GameObject("Scores");
					val2.transform.SetParent(val.transform, false);
					_board = val2.AddComponent<RectTransform>();
					_board.anchorMin = new Vector2(0.5f, 1f);
					_board.anchorMax = new Vector2(0.5f, 1f);
					_board.pivot = new Vector2(0.5f, 1f);
					_board.anchoredPosition = new Vector2(0f, -18f);
					_board.sizeDelta = new Vector2(1600f, 48f);
					HorizontalLayoutGroup obj2 = val2.AddComponent<HorizontalLayoutGroup>();
					((LayoutGroup)obj2).childAlignment = (TextAnchor)4;
					((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = true;
					((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = false;
					((HorizontalOrVerticalLayoutGroup)obj2).spacing = 36f;
					((LayoutGroup)obj2).padding = new RectOffset(0, 0, 0, 0);
					ContentSizeFitter obj3 = val2.AddComponent<ContentSizeFitter>();
					obj3.horizontalFit = (FitMode)2;
					obj3.verticalFit = (FitMode)2;
					_countShadow = MakeCountdown(val.transform, _font, "CountShadow", new Color(0f, 0f, 0f, 0.7f), new Vector2(6f, -6f));
					_countText = MakeCountdown(val.transform, _font, "Count", Color.white, Vector2.zero);
				}
			}
		}

		private static ScoreRow MakeRow(Transform parent, TMP_FontAsset font)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("PlayerScore");
			val.transform.SetParent(parent, false);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.preferredHeight = 40f;
			obj.preferredWidth = 260f;
			HorizontalLayoutGroup obj2 = val.AddComponent<HorizontalLayoutGroup>();
			((LayoutGroup)obj2).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 8f;
			((LayoutGroup)obj2).padding = new RectOffset(0, 0, 0, 0);
			GameObject val2 = new GameObject("Avatar");
			val2.transform.SetParent(val.transform, false);
			RawImage val3 = val2.AddComponent<RawImage>();
			((Graphic)val3).raycastTarget = false;
			((Graphic)val3).color = new Color(1f, 1f, 1f, 0.15f);
			LayoutElement obj3 = val2.AddComponent<LayoutElement>();
			obj3.preferredWidth = 32f;
			obj3.preferredHeight = 32f;
			obj3.minWidth = 32f;
			obj3.minHeight = 32f;
			TextMeshProUGUI name = MakeRowText(val.transform, font, "Name", 22f, 150f, (TextAlignmentOptions)513);
			TextMeshProUGUI val4 = MakeRowText(val.transform, font, "Score", 26f, 50f, (TextAlignmentOptions)516);
			((TMP_Text)val4).fontStyle = (FontStyles)1;
			return new ScoreRow
			{
				Root = val,
				Avatar = val3,
				Name = name,
				Score = val4
			};
		}

		private static TextMeshProUGUI MakeRowText(Transform parent, TMP_FontAsset font, string name, float size, float width, TextAlignmentOptions align)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			TextMeshProUGUI obj = val.AddComponent<TextMeshProUGUI>();
			ApplyFont(obj, font);
			((Graphic)obj).color = Color.white;
			((TMP_Text)obj).fontSize = size;
			((TMP_Text)obj).alignment = align;
			((TMP_Text)obj).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)obj).overflowMode = (TextOverflowModes)1;
			((Graphic)obj).raycastTarget = false;
			((TMP_Text)obj).text = "";
			LayoutElement obj2 = val.AddComponent<LayoutElement>();
			obj2.preferredWidth = width;
			obj2.preferredHeight = 36f;
			return obj;
		}

		private static TMP_FontAsset FindFont()
		{
			TextMeshProUGUI val = FindSampleText();
			if ((Object)(object)val != (Object)null && (Object)(object)((TMP_Text)val).font != (Object)null)
			{
				return ((TMP_Text)val).font;
			}
			try
			{
				if ((Object)(object)TMP_Settings.defaultFontAsset != (Object)null)
				{
					return TMP_Settings.defaultFontAsset;
				}
			}
			catch
			{
			}
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			if (array != null)
			{
				for (int i = 0; i < array.Length; i++)
				{
					if ((Object)(object)array[i] != (Object)null)
					{
						return array[i];
					}
				}
			}
			return null;
		}

		private static void ApplyFont(TextMeshProUGUI tmp, TMP_FontAsset font)
		{
			((TMP_Text)tmp).font = font;
			if ((Object)(object)font != (Object)null && (Object)(object)((TMP_Asset)font).material != (Object)null)
			{
				((TMP_Text)tmp).fontSharedMaterial = ((TMP_Asset)font).material;
			}
		}

		private static TextMeshProUGUI FindSampleText()
		{
			object? value = AccessTools.Field(typeof(CanvasManager), "_instance").GetValue(null);
			CanvasManager val = (CanvasManager)((value is CanvasManager) ? value : null);
			if ((Object)(object)val != (Object)null)
			{
				object? value2 = AccessTools.Field(typeof(CanvasManager), "_versionText").GetValue(val);
				TextMeshProUGUI val2 = (TextMeshProUGUI)((value2 is TextMeshProUGUI) ? value2 : null);
				if ((Object)(object)val2 != (Object)null && (Object)(object)((TMP_Text)val2).font != (Object)null)
				{
					return val2;
				}
			}
			object? value3 = AccessTools.Field(typeof(ButtonManager), "_instance").GetValue(null);
			ButtonManager val3 = (ButtonManager)((value3 is ButtonManager) ? value3 : null);
			if ((Object)(object)val3 != (Object)null)
			{
				object? value4 = AccessTools.Field(typeof(ButtonManager), "_islandText").GetValue(val3);
				TextMeshProUGUI val4 = (TextMeshProUGUI)((value4 is TextMeshProUGUI) ? value4 : null);
				if ((Object)(object)val4 != (Object)null && (Object)(object)((TMP_Text)val4).font != (Object)null)
				{
					return val4;
				}
			}
			return Object.FindObjectOfType<TextMeshProUGUI>();
		}

		private static TextMeshProUGUI MakeLobbyLabel(Transform parent, TMP_FontAsset font, string name, float y, float size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			TextMeshProUGUI obj = val.AddComponent<TextMeshProUGUI>();
			ApplyFont(obj, font);
			((Graphic)obj).color = Color.white;
			((TMP_Text)obj).fontSize = size;
			((TMP_Text)obj).alignment = (TextAlignmentOptions)258;
			((TMP_Text)obj).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)obj).overflowMode = (TextOverflowModes)0;
			((Graphic)obj).raycastTarget = false;
			((TMP_Text)obj).text = "";
			RectTransform rectTransform = ((TMP_Text)obj).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 1f);
			rectTransform.anchorMax = new Vector2(0.5f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.anchoredPosition = new Vector2(0f, y);
			rectTransform.sizeDelta = new Vector2(1400f, 40f);
			return obj;
		}

		private static TextMeshProUGUI MakeCountdown(Transform parent, TMP_FontAsset font, string name, Color color, Vector2 offset)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			TextMeshProUGUI obj = val.AddComponent<TextMeshProUGUI>();
			ApplyFont(obj, font);
			((Graphic)obj).color = color;
			((TMP_Text)obj).fontStyle = (FontStyles)1;
			((TMP_Text)obj).fontSize = 180f;
			((TMP_Text)obj).alignment = (TextAlignmentOptions)514;
			((TMP_Text)obj).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)obj).overflowMode = (TextOverflowModes)0;
			((Graphic)obj).raycastTarget = false;
			((TMP_Text)obj).text = "";
			RectTransform rectTransform = ((TMP_Text)obj).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.anchoredPosition = offset;
			rectTransform.sizeDelta = new Vector2(800f, 280f);
			return obj;
		}

		private static void PlayCountSound(bool go)
		{
			try
			{
				if (go)
				{
					AudioManager.PlayGlobalClip("Hitmarker", false, 1.3f, 0f, false);
				}
				else
				{
					AudioManager.PlayGlobalClip("Click", true, 1.45f, 0f, false);
				}
			}
			catch
			{
			}
		}

		private void OnGUI()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_005c: 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_006d: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			if ((PvpSession.Queued || PvpSession.MatchRunning) && (!((Object)(object)_canvas != (Object)null) || !((Component)_canvas).gameObject.activeSelf))
			{
				GUIStyle val = new GUIStyle(GUI.skin.label);
				val.alignment = (TextAnchor)1;
				val.fontSize = 32;
				val.fontStyle = (FontStyle)1;
				val.normal.textColor = Color.white;
				GUIStyle val2 = new GUIStyle(val);
				val2.fontSize = 20;
				val2.fontStyle = (FontStyle)0;
				GUI.Label(new Rect(0f, 18f, (float)Screen.width, 40f), "PVP MODE", val);
				bool flag = (Object)(object)Server.Instance != (Object)null && ((NetworkBehaviour)Server.Instance).IsServerInitialized;
				string text = (PvpSession.MatchRunning ? PvpSession.ScoreLine() : (flag ? "Waiting for players... host press F8 to start" : "Waiting for host to start"));
				GUI.Label(new Rect(0f, 56f, (float)Screen.width, 32f), text, val2);
				if (PvpSession.CountdownDisplay > 0)
				{
					GUI.Label(new Rect(0f, (float)Screen.height * 0.4f, (float)Screen.width, 80f), PvpSession.CountdownDisplay.ToString(), val);
				}
				else if (PvpSession.CountdownDisplay == 0)
				{
					GUI.Label(new Rect(0f, (float)Screen.height * 0.4f, (float)Screen.width, 80f), "GO", val);
				}
				else if (!string.IsNullOrEmpty(PvpSession.CenterBanner))
				{
					GUI.Label(new Rect(0f, (float)Screen.height * 0.38f, (float)Screen.width, 120f), PvpSession.CenterBanner, val);
				}
			}
		}
	}
	internal static class SteamAvatars
	{
		private static readonly Dictionary<ulong, Texture2D> Cache = new Dictionary<ulong, Texture2D>();

		internal static Texture2D Get(ulong steamId)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			if (steamId == 0L)
			{
				return null;
			}
			if (Cache.TryGetValue(steamId, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			try
			{
				int mediumFriendAvatar = SteamFriends.GetMediumFriendAvatar(new CSteamID(steamId));
				if (mediumFriendAvatar <= 0)
				{
					return null;
				}
				uint num = default(uint);
				uint num2 = default(uint);
				if (!SteamUtils.GetImageSize(mediumFriendAvatar, ref num, ref num2) || num == 0 || num2 == 0)
				{
					return null;
				}
				byte[] array = new byte[num * num2 * 4];
				if (!SteamUtils.GetImageRGBA(mediumFriendAvatar, array, array.Length))
				{
					return null;
				}
				Texture2D val = new Texture2D((int)num, (int)num2, (TextureFormat)4, false);
				((Texture)val).wrapMode = (TextureWrapMode)1;
				((Texture)val).filterMode = (FilterMode)1;
				val.LoadRawTextureData(FlipVertical(array, (int)num, (int)num2));
				val.Apply(false, false);
				Cache[steamId] = val;
				return val;
			}
			catch
			{
				return null;
			}
		}

		private static byte[] FlipVertical(byte[] src, int width, int height)
		{
			int num = width * 4;
			byte[] array = new byte[src.Length];
			for (int i = 0; i < height; i++)
			{
				int srcOffset = i * num;
				int dstOffset = (height - 1 - i) * num;
				Buffer.BlockCopy(src, srcOffset, array, dstOffset, num);
			}
			return array;
		}
	}
	internal static class PvpLava
	{
		private struct WaterPaint
		{
			public Renderer Rend;

			public Material[] Mats;
		}

		private struct SkyBackup
		{
			public bool Saved;

			public Material Skybox;

			public Color Ambient;

			public AmbientMode AmbientMode;

			public bool Fog;

			public Color FogColor;

			public FogMode FogMode;

			public float FogDensity;

			public float FogStart;

			public float FogEnd;
		}

		private struct LightBackup
		{
			public Light Light;

			public Color Color;

			public float Intensity;
		}

		private struct CamBackup
		{
			public Camera Cam;

			public CameraClearFlags Flags;

			public Color Back;
		}

		private const float SkyAboveWater = 26f;

		private const float Block = 11f;

		private const float BlockH = 1.15f;

		private const float Tilt = 20f;

		private static GameObject _root;

		private static GameObject _pad;

		private static int _layer;

		private static float _yaw;

		private static readonly List<Renderer> _hiddenRends = new List<Renderer>();

		private static readonly List<Collider> _hiddenCols = new List<Collider>();

		private static readonly List<WaterPaint> _waterPaint = new List<WaterPaint>();

		private static readonly List<Material> _ownedMats = new List<Material>();

		private static readonly List<Texture2D> _ownedTex = new List<Texture2D>();

		private static Material _savedWaterMat;

		private static object _waterManager;

		private static SkyBackup _sky;

		private static readonly List<LightBackup> _lights = new List<LightBackup>();

		private static readonly List<CamBackup> _cams = new List<CamBackup>();

		private static readonly Color LavaOrange = new Color(1f, 0.32f, 0f, 1f);

		private static readonly Color LavaOrangeHdr = new Color(2.2f, 0.55f, 0.02f, 1f);

		internal static bool IsActive
		{
			get
			{
				if ((Object)(object)_root != (Object)null)
				{
					return (Object)(object)_pad != (Object)null;
				}
				return false;
			}
		}

		internal static bool TryGetSpawn(out Vector3 pos, out float yaw)
		{
			return TryGetSlot(0, 1, out pos, out yaw);
		}

		internal static bool TryGetSlot(int slot, int count, out Vector3 pos, out float yaw)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			pos = Vector3.zero;
			yaw = _yaw;
			if (!IsActive)
			{
				return false;
			}
			Vector3 val = StandCenter();
			if (count < 1)
			{
				count = 1;
			}
			if (count == 1)
			{
				pos = val;
			}
			else
			{
				float num = 360f / (float)count * (float)slot;
				pos = val + Quaternion.Euler(0f, num, 0f) * Vector3.forward * 2.1f;
			}
			return true;
		}

		internal static void Destroy()
		{
			RestoreWorld();
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
			}
			_root = null;
			_pad = null;
		}

		internal unsafe static bool Build(int playerCount)
		{
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_0043: 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)
			Destroy();
			_layer = FirstJumpLayer();
			if (!TryIslandSpawn(out var pos, out var yaw))
			{
				pos = ((!((Object)(object)Player.LocalPlayer != (Object)null) || !((Object)(object)Player.LocalPlayer.Transform != (Object)null)) ? Vector3.zero : Player.LocalPlayer.Transform.position);
			}
			_yaw = yaw;
			float num = 0f;
			try
			{
				num = WaterManager.GetWaterHeight(pos);
			}
			catch
			{
				try
				{
					num = WaterManager.WaterHeight;
				}
				catch
				{
				}
			}
			Vector3 val = FindOpenWater(pos, num);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(val.x, num + 26f, val.z);
			_root = new GameObject("HowToFishPvpLava");
			_root.layer = _layer;
			try
			{
				_root.tag = "Level";
			}
			catch
			{
			}
			_root.transform.position = val2;
			MoveToIslandScene(_root);
			TintWaterOrange();
			MakeLavaKill(num, val);
			NightSky();
			_pad = MakeTiltBlock(val2);
			HideIsland();
			Physics.SyncTransforms();
			Debug.Log((object)("[HowToFishPvp] Lava tilt block at " + ((object)(*(Vector3*)(&val2))/*cast due to .constrained prefix*/).ToString() + " players=" + playerCount));
			return true;
		}

		private static Vector3 StandCenter()
		{
			//IL_000d: 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_007b: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_pad == (Object)null)
			{
				return Vector3.zero;
			}
			Collider component = _pad.GetComponent<Collider>();
			if ((Object)(object)component != (Object)null)
			{
				Bounds bounds = component.bounds;
				float x = ((Bounds)(ref bounds)).center.x;
				bounds = component.bounds;
				float num = ((Bounds)(ref bounds)).max.y + 1.08f;
				bounds = component.bounds;
				return new Vector3(x, num, ((Bounds)(ref bounds)).center.z);
			}
			return _pad.transform.position + Vector3.up * 1.655f;
		}

		private static GameObject MakeTiltBlock(Vector3 pos)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("LavaAnchor");
			val.transform.SetParent(_root.transform, true);
			val.transform.position = pos;
			Rigidbody val2 = val.AddComponent<Rigidbody>();
			val2.isKinematic = true;
			val2.useGravity = false;
			GameObject val3 = new GameObject("LavaBlock");
			val3.layer = _layer;
			try
			{
				val3.tag = "Level";
			}
			catch
			{
			}
			val3.transform.SetParent(_root.transform, true);
			val3.transform.position = pos;
			val3.transform.rotation = Quaternion.identity;
			GameObject obj2 = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)obj2).name = "RockVisual";
			obj2.layer = _layer;
			Object.Destroy((Object)(object)obj2.GetComponent<Collider>());
			obj2.transform.SetParent(val3.transform, false);
			obj2.transform.localPosition = Vector3.zero;
			obj2.transform.localRotation = Quaternion.identity;
			obj2.transform.localScale = new Vector3(11f, 1.15f, 11f);
			MeshRenderer component = obj2.GetComponent<MeshRenderer>();
			((Renderer)component).enabled = true;
			((Renderer)component).lightmapIndex = -1;
			((Renderer)component).sharedMaterial = MakeDarkStoneMat(((Renderer)component).sharedMaterial);
			BoxCollider obj3 = val3.AddComponent<BoxCollider>();
			obj3.size = new Vector3(11f, 1.15f, 11f);
			obj3.center = Vector3.zero;
			Rigidbody obj4 = val3.AddComponent<Rigidbody>();
			obj4.mass = 140f;
			obj4.useGravity = false;
			obj4.linearDamping = 1.2f;
			obj4.angularDamping = 4.2f;
			obj4.centerOfMass = new Vector3(0f, -0.35f, 0f);
			obj4.constraints = (RigidbodyConstraints)46;
			ConfigurableJoint obj5 = val3.AddComponent<ConfigurableJoint>();
			((Joint)obj5).connectedBody = val2;
			((Joint)obj5).autoConfigureConnectedAnchor = true;
			obj5.xMotion = (ConfigurableJointMotion)0;
			obj5.yMotion = (ConfigurableJointMotion)0;
			obj5.zMotion = (ConfigurableJointMotion)0;
			obj5.angularYMotion = (ConfigurableJointMotion)0;
			obj5.angularXMotion = (ConfigurableJointMotion)1;
			obj5.angularZMotion = (ConfigurableJointMotion)1;
			SoftJointLimit val4 = default(SoftJointLimit);
			((SoftJointLimit)(ref val4)).limit = 20f;
			SoftJointLimit lowAngularXLimit = default(SoftJointLimit);
			((SoftJointLimit)(ref lowAngularXLimit)).limit = -20f;
			obj5.lowAngularXLimit = lowAngularXLimit;
			obj5.highAngularXLimit = val4;
			obj5.angularZLimit = val4;
			JointDrive slerpDrive = default(JointDrive);
			((JointDrive)(ref slerpDrive)).positionSpring = 110f;
			((JointDrive)(ref slerpDrive)).positionDamper = 28f;
			((JointDrive)(ref slerpDrive)).maximumForce = 1E+09f;
			obj5.rotationDriveMode = (RotationDriveMode)1;
			obj5.slerpDrive = slerpDrive;
			obj5.targetRotation = Quaternion.identity;
			return val3;
		}

		private static Material MakeDarkStoneMat(Material fallback)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			Shader val = Shader.Find("Universal Render Pipeline/Lit");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("HDRP/Lit");
			}
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Standard");
			}
			Material val2 = ((!((Object)(object)val != (Object)null)) ? new Material(fallback) : new Material(val));
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.22f, 0.22f, 0.24f, 1f);
			val2.color = val3;
			if (val2.HasProperty("_BaseColor"))
			{
				val2.SetColor("_BaseColor", val3);
			}
			if (val2.HasProperty("_Color"))
			{
				val2.SetColor("_Color", val3);
			}
			if (val2.HasProperty("_Metallic"))
			{
				val2.SetFloat("_Metallic", 0.04f);
			}
			if (val2.HasProperty("_Smoothness"))
			{
				val2.SetFloat("_Smoothness", 0.16f);
			}
			if (val2.HasProperty("_Glossiness"))
			{
				val2.SetFloat("_Glossiness", 0.16f);
			}
			Texture val4 = FindDarkRockTexture();
			if ((Object)(object)val4 != (Object)null)
			{
				val2.mainTexture = val4;
				if (val2.HasProperty("_BaseMap"))
				{
					val2.SetTexture("_BaseMap", val4);
				}
				if (val2.HasProperty("_MainTex"))
				{
					val2.SetTexture("_MainTex", val4);
				}
			}
			_ownedMats.Add(val2);
			return val2;
		}

		private static Texture FindDarkRockTexture()
		{
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			Material val = null;
			float num = 999f;
			Renderer[] array = Object.FindObjectsOfType<Renderer>();
			if (array == null)
			{
				return null;
			}
			foreach (Renderer val2 in array)
			{
				if ((Object)(object)val2 == (Object)null || (Object)(object)val2.sharedMaterial == (Object)null || ((Object)(object)_root != (Object)null && ((Component)val2).transform.IsChildOf(_root.transform)))
				{
					continue;
				}
				string text = ((Object)((Component)val2).gameObject).name.ToLowerInvariant() + " " + ((Object)val2.sharedMaterial).name.ToLowerInvariant();
				if (text.IndexOf("water") >= 0 || text.IndexOf("sky") >= 0 || text.IndexOf("cloud") >= 0 || text.IndexOf("lava") >= 0 || text.IndexOf("magma") >= 0 || text.IndexOf("glow") >= 0 || (text.IndexOf("rock") < 0 && text.IndexOf("stone") < 0 && text.IndexOf("cliff") < 0 && text.IndexOf("basalt") < 0 && text.IndexOf("ash") < 0))
				{
					continue;
				}
				Color val3 = Color.gray;
				try
				{
					val3 = val2.sharedMaterial.color;
				}
				catch
				{
				}
				float num2 = val3.r * 0.3f + val3.g * 0.5f + val3.b * 0.2f;
				float num3 = Mathf.Max(new float[3] { val3.r, val3.g, val3.b }) - Mathf.Min(new float[3] { val3.r, val3.g, val3.b });
				if (!(val3.r > val3.g + 0.15f))
				{
					float num4 = num2 + num3 * 0.5f;
					if (text.IndexOf("rock") >= 0 || text.IndexOf("stone") >= 0)
					{
						num4 -= 0.1f;
					}
					if (num4 < num)
					{
						num = num4;
						val = val2.sharedMaterial;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if ((Object)(object)val.mainTexture != (Object)null)
			{
				return val.mainTexture;
			}
			if (val.HasProperty("_BaseMap"))
			{
				return val.GetTexture("_BaseMap");
			}
			if (val.HasProperty("_MainTex"))
			{
				return val.GetTexture("_MainTex");
			}
			return null;
		}

		private static void TintWaterOrange()
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			_waterPaint.Clear();
			_savedWaterMat = null;
			_waterManager = null;
			Dictionary<Material, Material> dictionary = new Dictionary<Material, Material>();
			List<Renderer> list = WaterRenderers();
			for (int i = 0; i < list.Count; i++)
			{
				Renderer val = list[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				_waterPaint.Add(new WaterPaint
				{
					Rend = val,
					Mats = sharedMaterials
				});
				int num = ((sharedMaterials != null) ? sharedMaterials.Length : 0);
				if (num == 0)
				{
					continue;
				}
				Material[] array = (Material[])(object)new Material[num];
				for (int j = 0; j < num; j++)
				{
					Material val2 = sharedMaterials[j];
					if (!((Object)(object)val2 == (Object)null))
					{
						if (!dictionary.TryGetValue(val2, out var value))
						{
							value = (dictionary[val2] = TintClone(val2));
						}
						array[j] = value;
					}
				}
				val.sharedMaterials = array;
				val.enabled = true;
				MaterialPropertyBlock val4 = new MaterialPropertyBlock();
				val.GetPropertyBlock(val4);
				ForceOrangeBlock(val4);
				val.SetPropertyBlock(val4);
			}
			try
			{
				_waterManager = AccessTools.Field(typeof(WaterManager), "_instance").GetValue(null);
				if (_waterManager == null)
				{
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(WaterManager), "_waterMat");
				object? value2 = fieldInfo.GetValue(_waterManager);
				Material val5 = (Material)((value2 is Material) ? value2 : null);
				if ((Object)(object)val5 != (Object)null)
				{
					_savedWaterMat = val5;
					if (!dictionary.TryGetValue(val5, out var value3))
					{
						value3 = TintClone(val5);
					}
					fieldInfo.SetValue(_waterManager, value3);
				}
			}
			catch
			{
			}
		}

		private static List<Renderer> WaterRenderers()
		{
			List<Renderer> list = new List<Renderer>();
			try
			{
				object value = AccessTools.Field(typeof(WaterManager), "_instance").GetValue(null);
				if (value != null && AccessTools.Field(typeof(WaterManager), "_waterTiles").GetValue(value) is Renderer[] array)
				{
					for (int i = 0; i < array.Length; i++)
					{
						if ((Object)(object)array[i] != (Object)null)
						{
							list.Add(array[i]);
						}
					}
				}
			}
			catch
			{
			}
			Transform val = MainWater();
			if ((Object)(object)val != (Object)null)
			{
				Renderer[] componentsInChildren = ((Component)val).GetComponentsInChildren<Renderer>(true);
				if (componentsInChildren != null)
				{
					for (int j = 0; j < componentsInChildren.Length; j++)
					{
						if ((Object)(object)componentsInChildren[j] != (Object)null)
						{
							list.Add(componentsInChildren[j]);
						}
					}
				}
			}
			Renderer[] array2 = Object.FindObjectsOfType<Renderer>();
			if (array2 != null)
			{
				for (int k = 0; k < array2.Length; k++)
				{
					if (!((Object)(object)array2[k] == (Object)null))
					{
						string text = ((Object)((Component)array2[k]).gameObject).name.ToLowerInvariant();
						if (text.IndexOf("water") >= 0 || text.IndexOf("ocean") >= 0 || text.IndexOf("sea") >= 0 || text.IndexOf("wave") >= 0)
						{
							list.Add(array2[k]);
						}
					}
				}
			}
			List<Renderer> list2 = new List<Renderer>();
			for (int l = 0; l < list.Count; l++)
			{
				bool flag = false;
				for (int m = 0; m < list2.Count; m++)
				{
					if ((Object)(object)list2[m] == (Object)(object)list[l])
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					list2.Add(list[l]);
				}
			}
			return list2;
		}

		private static Material TintClone(Material src)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			Material val = new Material(src);
			ForceOrangeMat(val);
			_ownedMats.Add(val);
			return val;
		}

		private static void ForceOrangeMat(Material mat)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Invalid comparison between Unknown and I4
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Invalid comparison between Unknown and I4
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mat == (Object)null)
			{
				return;
			}
			mat.color = LavaOrange;
			string[] array = new string[23]
			{
				"_Color", "_BaseColor", "_Color1", "_Color2", "_Tint", "_TintColor", "_ShallowColor", "_DeepColor", "_HorizonColor", "_AbsorptionColor",
				"_ScatterColor", "_FoamColor", "_WaterColor", "_TopColor", "_BottomColor", "_GradientColor", "_GradientColor1", "_GradientColor2", "_PeakColor", "_EmissionColor",
				"_Emission", "_EmissiveColor", "_GlowColor"
			};
			for (int i = 0; i < array.Length; i++)
			{
				if (mat.HasProperty(array[i]))
				{
					mat.SetColor(array[i], (array[i].IndexOf("Emission") >= 0 || array[i].IndexOf("Glow") >= 0 || array[i].IndexOf("Emissive") >= 0) ? LavaOrangeHdr : LavaOrange);
				}
			}
			try
			{
				Shader shader = mat.shader;
				if ((Object)(object)shader != (Object)null)
				{
					Texture2D val = null;
					int propertyCount = shader.GetPropertyCount();
					for (int j = 0; j < propertyCount; j++)
					{
						string propertyName = shader.GetPropertyName(j);
						ShaderPropertyType propertyType = shader.GetPropertyType(j);
						if ((int)propertyType == 0)
						{
							mat.SetColor(propertyName, IsEmitName(propertyName) ? LavaOrangeHdr : LavaOrange);
						}
						else if ((int)propertyType == 1 && IsColorName(propertyName))
						{
							mat.SetVector(propertyName, Color.op_Implicit(LavaOrange));
						}
						else if ((int)propertyType == 4 && IsAlbedoName(propertyName) && !IsSkipTex(propertyName))
						{
							if ((Object)(object)val == (Object)null)
							{
								val = MakeOrangeRamp();
							}
							mat.SetTexture(propertyName, (Texture)(object)val);
						}
					}
				}
			}
			catch
			{
			}
			mat.EnableKeyword("_EMISSION");
			mat.EnableKeyword("_EMISSIVE");
			mat.globalIlluminationFlags = (MaterialGlobalIlluminationFlags)1;
		}

		private static void ForceOrangeBlock(MaterialPropertyBlock block)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			block.SetColor("_Color", LavaOrange);
			block.SetColor("_BaseColor", LavaOrange);
			block.SetColor("_Tint", LavaOrange);
			block.SetColor("_ShallowColor", LavaOrange);
			block.SetColor("_DeepColor", new Color(0.85f, 0.18f, 0f, 1f));
			block.SetColor("_FoamColor", new Color(1f, 0.55f, 0.08f, 1f));
			block.SetColor("_EmissionColor", LavaOrangeHdr);
		}

		private static bool IsEmitName(string n)
		{
			n = n.ToLowerInvariant();
			if (n.IndexOf("emission") < 0 && n.IndexOf("emissive") < 0)
			{
				return n.IndexOf("glow") >= 0;
			}
			return true;
		}

		private static bool IsColorName(string n)
		{
			n = n.ToLowerInvariant();
			if (n.IndexOf("color") < 0 && n.IndexOf("tint") < 0 && n.IndexOf("shallow") < 0 && n.IndexOf("deep") < 0 && n.IndexOf("foam") < 0 && n.IndexOf("horizon") < 0 && n.IndexOf("scatter") < 0)
			{
				return n.IndexOf("absorb") >= 0;
			}
			return true;
		}

		private static bool IsAlbedoName(string n)
		{
			n = n.ToLowerInvariant();
			if (n.IndexOf("color") < 0 && n.IndexOf("albedo") < 0 && n.IndexOf("gradient") < 0 && n.IndexOf("ramp") < 0 && n.IndexOf("diffuse") < 0 && n.IndexOf("tint") < 0 && n.IndexOf("basemap") < 0 && n.IndexOf("maintex") < 0)
			{
				return n.IndexOf("basecolor") >= 0;
			}
			return true;
		}

		private static bool IsSkipTex(string n)
		{
			n = n.ToLowerInvariant();
			if (n.IndexOf("normal") < 0 && n.IndexOf("bump") < 0 && n.IndexOf("noise") < 0 && n.IndexOf("wave") < 0 && n.IndexOf("height") < 0 && n.IndexOf("mask") < 0 && n.IndexOf("flow") < 0 && n.IndexOf("distort") < 0 && n.IndexOf("cube") < 0 && n.IndexOf("reflect") < 0)
			{
				return n.IndexOf("metal") >= 0;
			}
			return true;
		}

		private static Texture2D MakeOrangeRamp()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(64, 8, (TextureFormat)4, false);
			((Texture)val).wrapMode = (TextureWrapMode)1;
			for (int i = 0; i < 8; i++)
			{
				for (int j = 0; j < 64; j++)
				{
					float num = (float)j / 63f;
					Color val2 = Color.Lerp(new Color(0.9f, 0.16f, 0f, 1f), new Color(1f, 0.55f, 0.05f, 1f), num);
					val.SetPixel(j, i, val2);
				}
			}
			val.Apply();
			_ownedTex.Add(val);
			return val;
		}

		private static void MakeLavaKill(float waterY, Vector3 xz)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("LavaGlow");
			val.transform.SetParent(_root.transform, true);
			val.transform.position = new Vector3(xz.x, waterY + 6f, xz.z);
			Light obj = val.AddComponent<Light>();
			obj.type = (LightType)2;
			obj.color = new Color(1f, 0.32f, 0.04f);
			obj.intensity = 5.5f;
			obj.range = 90f;
			GameObject val2 = new GameObject("LavaKill");
			val2.transform.SetParent(_root.transform, true);
			val2.transform.position = new Vector3(xz.x, waterY + 1.2f, xz.z);
			BoxCollider obj2 = val2.AddComponent<BoxCollider>();
			((Collider)obj2).isTrigger = true;
			obj2.size = new Vector3(420f, 6f, 420f);
			val2.AddComponent<PvpLavaKill>();
		}

		private static void NightSky()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Invalid comparison between Unknown and I4
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			_sky = new SkyBackup
			{
				Saved = true,
				Skybox = RenderSettings.skybox,
				Ambient = RenderSettings.ambientLight,
				AmbientMode = RenderSettings.ambientMode,
				Fog = RenderSettings.fog,
				FogColor = RenderSettings.fogColor,
				FogMode = RenderSettings.fogMode,
				FogDensity = RenderSettings.fogDensity,
				FogStart = RenderSettings.fogStartDistance,
				FogEnd = RenderSettings.fogEndDistance
			};
			Color val = default(Color);
			((Color)(ref val))..ctor(0.03f, 0.035f, 0.08f);
			Material val2 = null;
			if ((Object)(object)RenderSettings.skybox != (Object)null)
			{
				val2 = new Material(RenderSettings.skybox);
				_ownedMats.Add(val2);
				if (val2.HasProperty("_Exposure"))
				{
					val2.SetFloat("_Exposure", 0.04f);
				}
				if (val2.HasProperty("_Tint"))
				{
					val2.SetColor("_Tint", new Color(0.12f, 0.14f, 0.28f));
				}
				if (val2.HasProperty("_SkyTint"))
				{
					val2.SetColor("_SkyTint", new Color(0.08f, 0.1f, 0.22f));
				}
				if (val2.HasProperty("_GroundColor"))
				{
					val2.SetColor("_GroundColor", new Color(0.02f, 0.02f, 0.04f));
				}
				if (val2.HasProperty("_AtmosphereThickness"))
				{
					val2.SetFloat("_AtmosphereThickness", 0.35f);
				}
				if (val2.HasProperty("_SunSize"))
				{
					val2.SetFloat("_SunSize", 0.01f);
				}
			}
			RenderSettings.skybox = val2;
			RenderSettings.ambientMode = (AmbientMode)3;
			RenderSettings.ambientLight = new Color(0.05f, 0.055f, 0.1f);
			RenderSettings.fog = true;
			RenderSettings.fogMode = (FogMode)3;
			RenderSettings.fogColor = val;
			RenderSettings.fogDensity = 0.008f;
			_lights.Clear();
			Light[] array = Object.FindObjectsOfType<Light>();
			if (array != null)
			{
				foreach (Light val3 in array)
				{
					if (!((Object)(object)val3 == (Object)null))
					{
						_lights.Add(new LightBackup
						{
							Light = val3,
							Color = val3.color,
							Intensity = val3.intensity
						});
						if ((int)val3.type == 1)
						{
							val3.color = new Color(0.45f, 0.55f, 0.9f);
							val3.intensity = Mathf.Min(val3.intensity, 0.12f);
						}
						else
						{
							val3.intensity *= 0.25f;
						}
					}
				}
			}
			_cams.Clear();
			Camera[] array2 = Object.FindObjectsOfType<Camera>();
			if (array2 == null)
			{
				return;
			}
			foreach (Camera val4 in array2)
			{
				if (!((Object)(object)val4 == (Object)null))
				{
					_cams.Add(new CamBackup
					{
						Cam = val4,
						Flags = val4.clearFlags,
						Back = val4.backgroundColor
					});
					val4.clearFlags = (CameraClearFlags)(((Object)(object)val2 != (Object)null) ? 1 : 2);
					val4.backgroundColor = val;
				}
			}
		}

		private static void HideIsland()
		{
			Transform waterXf = MainWater();
			Renderer[] array = Object.FindObjectsOfType<Renderer>();
			if (array != null)
			{
				foreach (Renderer val in array)
				{
					if (!((Object)(object)val == (Object)null) && val.enabled && !KeepVisible(((Component)val).transform, waterXf))
					{
						val.enabled = false;
						_hiddenRends.Add(val);
					}
				}
			}
			Collider[] array2 = Object.FindObjectsOfType<Collider>();
			if (array2 == null)
			{
				return;
			}
			foreach (Collider val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null) && val2.enabled && !KeepVisible(((Component)val2).transform, waterXf))
				{
					val2.enabled = false;
					_hiddenCols.Add(val2);
				}
			}
		}

		private static bool KeepVisible(Transform t, Transform waterXf)
		{
			if ((Object)(object)t == (Object)null)
			{
				return true;
			}
			if ((Object)(object)_root != (Object)null && ((Object)(object)t == (Object)(object)_root.transform || t.IsChildOf(_root.transform)))
			{
				return true;
			}
			if ((Object)(object)((Component)t).GetComponentInParent<Player>() != (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)t).GetComponentInParent<Item>() != (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)t).GetComponentInParent<MainLava>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)t).GetComponentInParent<ExtraLava>() != (Object)null)
			{
				return false;
			}
			string text = ((Object)((Component)t).gameObject).name.ToLowerInvariant();
			if (text.IndexOf("lava") >= 0 || text.IndexOf("magma") >= 0 || text.IndexOf("volcano") >= 0)
			{
				return false;
			}
			if ((Object)(object)waterXf != (Object)null && ((Object)(object)t == (Object)(object)waterXf || t.IsChildOf(waterXf)))
			{
				return true;
			}
			if (text.IndexOf("howtofish") >= 0 || text.IndexOf("lavablock") >= 0)
			{
				return true;
			}
			if (text.IndexOf("water") >= 0 || text.IndexOf("ocean") >= 0 || text.IndexOf("sea") >= 0)
			{
				return true;
			}
			if (text.IndexOf("wave") >= 0 || text.IndexOf("horizon") >= 0)
			{
				return true;
			}
			return false;
		}

		private static void RestoreWorld()
		{
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (_waterManager != null && (Object)(object)_savedWaterMat != (Object)null)
				{
					AccessTools.Field(typeof(WaterManager), "_waterMat").SetValue(_waterManager, _savedWaterMat);
				}
			}
			catch
			{
			}
			_waterManager = null;
			_savedWaterMat = null;
			for (int i = 0; i < _waterPaint.Count; i++)
			{
				if ((Object)(object)_waterPaint[i].Rend != (Object)null && _waterPaint[i].Mats != null)
				{
					_waterPaint[i].Rend.sharedMaterials = _waterPaint[i].Mats;
					_waterPaint[i].Rend.SetPropertyBlock((MaterialPropertyBlock)null);
				}
			}
			_waterPaint.Clear();
			for (int j = 0; j < _ownedMats.Count; j++)
			{
				if ((Object)(object)_ownedMats[j] != (Object)null)
				{
					Object.Destroy((Object)(object)_ownedMats[j]);
				}
			}
			_ownedMats.Clear();
			for (int k = 0; k < _ownedTex.Count; k++)
			{
				if ((Object)(object)_ownedTex[k] != (Object)null)
				{
					Object.Destroy((Object)(object)_ownedTex[k]);
				}
			}
			_ownedTex.Clear();
			for (int l = 0; l < _hiddenRends.Count; l++)
			{
				if ((Object)(object)_hiddenRends[l] != (Object)null)
				{
					_hiddenRends[l].enabled = true;
				}
			}
			_hiddenRends.Clear();
			for (int m = 0; m < _hiddenCols.Count; m++)
			{
				if ((Object)(object)_hiddenCols[m] != (Object)null)
				{
					_hiddenCols[m].enabled = true;
				}
			}
			_hiddenCols.Clear();
			if (_sky.Saved)
			{
				RenderSettings.skybox = _sky.Skybox;
				RenderSettings.ambientLight = _sky.Ambient;
				RenderSettings.ambientMode = _sky.AmbientMode;
				RenderSettings.fog = _sky.Fog;
				RenderSettings.fogColor = _sky.FogColor;
				RenderSettings.fogMode = _sky.FogMode;
				RenderSettings.fogDensity = _sky.FogDensity;
				RenderSettings.fogStartDistance = _sky.FogStart;
				RenderSettings.fogEndDistance = _sky.FogEnd;
				_sky.Saved = false;
			}
			for (int n = 0; n < _lights.Count; n++)
			{
				if (!((Object)(object)_lights[n].Light == (Object)null))
				{
					_lights[n].Light.color = _lights[n].Color;
					_lights[n].Light.intensity = _lights[n].Intensity;
				}
			}
			_lights.Clear();
			for (int num = 0; num < _cams.Count; num++)
			{
				if (!((Object)(object)_cams[num].Cam == (Object)null))
				{
					_cams[num].Cam.clearFlags = _cams[num].Flags;
					_cams[num].Cam.backgroundColor = _cams[num].Back;
				}
			}
			_cams.Clear();
		}

		private static Transform MainWater()
		{
			try
			{
				object value = AccessTools.Field(typeof(WaterManager), "_instance").GetValue(null);
				if (value != null)
				{
					object? value2 = AccessTools.Field(typeof(WaterManager), "_mainWater").GetValue(value);
					return (Transform)((value2 is Transform) ? value2 : null);
				}
			}
			catch
			{
			}
			return null;
		}

		private static Vector3 FindOpenWater(Vector3 island, float water)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			try
			{
				num = LayerMask.op_Implicit(GameInfo.LevelLayer);
			}
			catch
			{
			}
			try
			{
				num |= LayerMask.op_Implicit(GameInfo.CanJumpOnLayers);
			}
			catch
			{
			}
			if (num == 0)
			{
				num = -5;
			}
			Vector3[] obj3 = new Vector3[6]
			{
				Vector3.forward,
				Vector3.back,
				Vector3.right,
				Vector3.left,
				default(Vector3),
				default(Vector3)
			};
			Vector3 val = Vector3.forward + Vector3.right;
			obj3[4] = ((Vector3)(ref val)).normalized;
			val = Vector3.back + Vector3.left;
			obj3[5] = ((Vector3)(ref val)).normalized;
			Vector3[] array = (Vector3[])(object)obj3;
			float[] array2 = new float[3] { 80f, 120f, 160f };
			RaycastHit val3 = default(RaycastHit);
			for (int i = 0; i < array2.Length; i++)
			{
				for (int j = 0; j < array.Length; j++)
				{
					Vector3 val2 = island + array[j] * array2[i];
					if (!Physics.Raycast(val2 + Vector3.up * 80f, Vector3.down, ref val3, 130f, num, (QueryTriggerInteraction)1))
					{
						return val2;
					}
					if (((RaycastHit)(ref val3)).point.y <= water + 1.8f)
					{
						return val2;
					}
				}
			}
			return island + Vector3.right * 130f;
		}

		private static void MoveToIslandScene(GameObject go)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)Island.CurIsland != (Object)null)
				{
					SceneManager.MoveGameObjectToScene(go, ((Component)Island.CurIsland).gameObject.scene);
				}
			}
			catch
			{
			}
		}

		private static int FirstJumpLayer()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			try
			{
				num = LayerMask.op_Implicit(GameInfo.CanJumpOnLayers);
			}
			catch
			{
			}
			for (int i = 0; i < 32; i++)
			{
				if ((num & (1 << i)) != 0)
				{
					return i;
				}
			}
			return 0;
		}

		private static bool TryIslandSpawn(out Vector3 pos, out float yaw)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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)
			pos = Vector3.zero;
			yaw = 0f;
			try
			{
				SpawnManager[] array = Object.FindObjectsOfType<SpawnManager>();
				if (array == null)
				{
					return false;
				}
				foreach (SpawnManager val in array)
				{
					if ((Object)(object)val == (Object)null || !((Behaviour)val).isActiveAndEnabled)
					{
						continue;
					}
					object? value = AccessTools.Field(typeof(SpawnManager), "_playerSpawnPoint").GetValue(val);
					Transform val2 = (Transform)((value is Transform) ? value : null);
					if (!((Object)(object)val2 == (Object)null))
					{
						pos = val2.position;
						yaw = val2.eulerAngles.y;
						if (((Vector3)(ref pos)).sqrMagnitude > 0.01f)
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}
	}
	internal sealed class PvpLavaKill : MonoBehaviour
	{
		private void OnTriggerStay(Collider col)
		{
			if ((Object)(object)col == (Object)null)
			{
				return;
			}
			try
			{
				MainLava val = Object.FindObjectOfType<MainLava>();
				if ((Object)(object)val != (Object)null)
				{
					val.TouchLava(col);
				}
			}
			catch
			{
			}
		}
	}
	internal static class PvpLobby
	{
		internal static bool IsSkyLobby()
		{
			if (PvpSession.Queued && !PvpSession.MatchRunning)
			{
				return PvpSession.Phase != PvpPhase.MatchOver;
			}
			return false;
		}

		internal static bool TryGetSpawn(out Vector3 pos, out float yaw)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			pos = Vector3.zero;
			yaw = 0f;
			return false;
		}

		internal static void Ensure()
		{
		}

		internal static void DestroyPad()
		{
			SetGod(on: false);
		}

		internal static void SetGod(bool on)
		{
			try
			{
				AccessTools.Field(typeof(PlayerManager), "<InGodMode>k__BackingField").SetValue(null, on);
			}
			catch
			{
			}
		}

		internal static void ForceHealth(Player player)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player.Vitals == (Object)null)
			{
				return;
			}
			try
			{
				AccessTools.Field(typeof(PlayerVitals), "_invulnerableUntil").SetValue(player.Vitals, Time.time + 8f);
				AccessTools.Field(typeof(PlayerVitals), "_localHp").SetValue(player.Vitals, 100);
				AccessTools.Field(typeof(PlayerVitals), "_localIsDead").SetValue(player.Vitals, false);
			}
			catch
			{
			}
			try
			{
				if (((NetworkBehaviour)player.Vitals).IsServerInitialized)
				{
					player.Vitals.ServerResetVitals();
				}
			}
			catch
			{
			}
		}
	}
	public enum PvpPhase
	{
		Idle,
		WaitingForPlayers,
		Countdown,
		Fighting,
		RoundOver,
		MatchOver
	}
	public static class PvpSession
	{
		public const int RoundCount = 20;

		public const float RoundSeconds = 90f;

		public const string SaveName = "PVP Arena";

		public const int ForestIsland = 1;

		public const int DesertIsland = 2;

		public const int VolcanoIsland = 4;

		public const int LobbyIsland = 1;

		public static bool Queued;

		public static bool MatchRunning;

		public static bool LobbyMoved;

		public static bool LobbyReady;

		public static PvpPhase Phase = PvpPhase.Idle;

		public static int Round = 0;

		public static int BalanceRound = 0;

		public static int MapSeed = 0;

		public static int IslandIndex = 1;

		public static float RoundEndsAt;

		public static float FightStartedAt;

		public static float ProtectUntil;

		public static int CountdownDisplay = -1;

		public static string Banner = "";

		public static string SubBanner = "";

		public static string CenterBanner = "";

		public static ulong SpectateSteam;

		public static int FloodState;

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

		public static readonly Dictionary<string, string> Names = new Dictionary<string, string>();

		public static void EnsureQueued()
		{
			if (!Queued)
			{
				Queued = true;
				if (Phase == PvpPhase.Idle)
				{
					Phase = PvpPhase.WaitingForPlayers;
				}
				Banner = "PVP MODE";
				if (string.IsNullOrEmpty(SubBanner))
				{
					SubBanner = "Waiting for players... host press F8 to start";
				}
			}
		}

		public static void ResetMatch()
		{
			MatchRunning = false;
			LobbyMoved = false;
			LobbyReady = false;
			Phase = PvpPhase.Idle;
			Round = 0;
			BalanceRound = 0;
			MapSeed = 0;
			PvpArena.ClearPlan();
			IslandIndex = 1;
			ProtectUntil = 0f;
			FightStartedAt = 0f;
			CountdownDisplay = -1;
			Banner = "";
			SubBanner = "";
			CenterBanner = "";
			SpectateSteam = 0uL;
			FloodState = 0;
			Scores.Clear();
			Names.Clear();
		}

		public static string Key(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return "unknown";
			}
			if (!string.IsNullOrEmpty(player.SteamName))
			{
				return player.SteamName;
			}
			return "Player " + ((object)player).GetHashCode();
		}

		public static void EnsurePlayer(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				string text = Key(player);
				if (!Scores.ContainsKey(text))
				{
					Scores[text] = 0;
				}
				Names[text] = text;
			}
		}

		public static void AwardRound(Player winner)
		{
			if (!((Object)(object)winner == (Object)null))
			{
				EnsurePlayer(winner);
				string key = Key(winner);
				Scores[key] += 1;
			}
		}

		public static string ScoreLine()
		{
			if (Scores.Count == 0)
			{
				return "No scores yet";
			}
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, int> score in Scores)
			{
				if (!Names.TryGetValue(score.Key, out var value))
				{
					value = "Player";
				}
				list.Add(value + "  " + score.Value);
			}
			list.Sort();
			return string.Join("   |   ", list.ToArray());
		}
	}
	internal sealed class PvpSpikeMark : MonoBehaviour
	{
		private float _nextPaint;

		private void LateUpdate()
		{
			if (!(Time.unscaledTime < _nextPaint))
			{
				_nextPaint = Time.unscaledTime + 0.35f;
				PvpSpike.StampMarks();
				PvpSpike.DressGun(((Component)this).GetComponent<Item>());
			}
		}
	}
	internal sealed class PvpSpikeFish : MonoBehaviour
	{
		internal float DieAt;

		private void LateUpdate()
		{
			if (!(Time.time < DieAt))
			{
				PvpSpike.Despawn(((Component)this).GetComponent<Item>());
			}
		}
	}
	[HarmonyPatch]
	internal static class PvpSpike
	{
		private const int MaxLive = 8;

		private const float FishLife = 22f;

		private static Item _gunPrefab;

		private static Creature _fishPrefab;

		private static readonly Dictionary<ulong, string> LastShot = new Dictionary<ulong, string>();

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

		private static readonly List<Item> LiveFish = new List<Item>();

		private static Vector3 _lastPos;

		private static float _lastAt;

		private static int _seq;

		private static float _nextStamp;

		private static bool _loggedSkins;

		internal unsafe static void DropFromSky()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHost())
			{
				return;
			}
			Server instance = Server.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Item val = GunPrefab();
			if ((Object)(object)val == (Object)null)
			{
				Debug.Log((object)"[HowToFishPvp] spike m4: no assault rifle prefab");
				return;
			}
			Player localPlayer = Player.LocalPlayer;
			Vector3 val2 = Vector3.zero;
			if ((Object)(object)localPlayer != (Object)null)
			{
				try
				{
					val2 = (((Object)(object)localPlayer.Transform != (Object)null) ? localPlayer.Transform.position : ((Component)localPlayer).transform.position);
				}
				catch
				{
					val2 = ((Component)localPlayer).transform.position;
				}
			}
			if (!(((Vector3)(ref val2)).sqrMagnitude < 0.01f))
			{
				Vector3 val3 = val2 + Vector3.up * Random.Range(11f, 16f);
				Quaternion val4 = Quaternion.Euler(Random.Range(0f, 360f), Random.Range(0f, 360f), Random.Range(0f, 360f));
				Item val5 = Object.Instantiate<Item>(val, val3, val4);
				if (!((Object)(object)val5 == (Object)null))
				{
					((Component)val5).transform.SetParent((Transform)null, true);
					((Component)val5).transform.position = val3;
					((NetworkBehaviour)instance).Spawn(((Component)val5).gameObject, (NetworkConnection)null, default(Scene));
					((Component)val5).transform.position = val3;
					RegisterSpawned(val5);
					((Component)val5).gameObject.AddComponent<SlowDrop>().HoldPos = val3;
					KickDown(val5);
					Debug.Log((object)("[HowToFishPvp] dropped spike m4 at " + ((object)(*(Vector3*)(&val3))/*cast due to .constrained prefix*/).ToString()));
				}
			}
		}

		internal static void RegisterSpawned(Item spawned)
		{
			if (!((Object)(object)spawned == (Object)null))
			{
				if ((Object)(object)((Component)spawned).GetComponent<PvpSpikeMark>() == (Object)null)
				{
					((Component)spawned).gameObject.AddComponent<PvpSpikeMark>();
				}
				DressGun(spawned);
				int num = IdOf(spawned);
				if (num != 0)
				{
					KnownIds.Add(num);
					PvpSync.Send("spikegun " + num);
				}
				PvpBoom.PlayMythicCatch();
				PvpSync.Send("mythic");
			}
		}

		internal static void HearGunId(int id)
		{
			if (id != 0)
			{
				KnownIds.Add(id);
				StampMarks();
			}
		}

		internal static void StampMarks()
		{
			if (KnownIds.Count == 0 || Time.unscaledTime < _nextStamp)
			{
				return;
			}
			_nextStamp = Time.unscaledTime + 0.25f;
			try
			{
				Dictionary<Transform, Item> items = ItemManager.Items;
				if (items == null)
				{
					return;
				}
				foreach (KeyValuePair<Transform, Item> item in items)
				{
					Item value = item.Value;
					if (!((Object)(object)value == (Object)null))
					{
						int num = IdOf(value);
						if (num != 0 && KnownIds.Contains(num) && (Object)(object)((Component)value).GetComponent<PvpSpikeMark>() == (Object)null)
						{
							((Component)value).gameObject.AddComponent<PvpSpikeMark>();
						}
					}
				}
			}
			catch
			{
			}
		}

		internal static void HearFrom(ulong steam, string data)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (IsHost() && !string.IsNullOrEmpty(data) && (!LastShot.TryGetValue(steam, out var value) || !(value == data)))
			{
				LastShot[steam] = data;
				if (ParsePos(data, out var pos))
				{
					SpawnFishAt(pos, PlayerBySteam(steam));
				}
			}
		}

		internal static void DressGun(Item item)
		{
			if ((Object)(object)item == (Object)null || !IsHost())
			{
				return;
			}
			int num = CoolSkinIndex(item);
			if (num >= 0)
			{
				try
				{
					if (item.CurSkin != (byte)num)
					{
						item.ServerSetSkin((byte)num);
					}
				}
				catch
				{
				}
			}
			EquipRedDot(item);
		}

		internal static void SetMemberShot(Vector3 pos)
		{
			_seq++;
			PvpSync.SetMemberSpike(pos.x.ToString("F2", CultureInfo.InvariantCulture) + " " + pos.y.ToString("F2", CultureInfo.InvariantCulture) + " " + pos.z.ToString("F2", CultureInfo.InvariantCulture) + " " + _seq);
		}

		internal static void Wipe()
		{
			for (int num = LiveFish.Count - 1; num >= 0; num--)
			{
				Despawn(LiveFish[num]);
			}
			LiveFish.Clear();
		}

		internal static void Despawn(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			LiveFish.Remove(item);
			try
			{
				item.DestroyItem((byte)0, byte.MaxValue);
			}
			catch
			{
				try
				{
					Object.Destroy((Object)(object)((Component)item).gameObject);
				}
				catch
				{
				}
			}
		}

		private static void Request(Vector3 pos, Player shooter)
		{
			//IL_000f: 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)
			if (IsHost())
			{
				SpawnFishAt(pos, shooter);
			}
			else
			{
				SetMemberShot(pos);
			}
		}

		private static void SpawnFishAt(Vector3 pos, Player shooter)
		{
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHost())
			{
				return;
			}
			if (Time.time - _lastAt < 0.12f)
			{
				Vector3 val = pos - _lastPos;
				if (((Vector3)(ref val)).sqrMagnitude < 4f)
				{
					return;
				}
			}
			_lastAt = Time.time;
			_lastPos = pos;
			Server instance = Server.Instance;
			Creature val2 = FishPrefab();
			if ((Object)(object)instance == (Object)null || (Object)(object)val2 == (Object)null)
			{
				Debug.Log((object)"[HowToFishPvp] spike m4: no sea urchin prefab");
				return;
			}
			PruneLive();
			while (LiveFish.Count >= 8)
			{
				Despawn(LiveFish[0]);
			}
			Vector3 val3 = pos + Vector3.up * 0.45f;
			Creature val4 = Object.Instantiate<Creature>(val2, val3, Random.rotation);
			if (!((Object)(object)val4 == (Object)null))
			{
				((Component)val4).transform.SetParent((Transform)null, true);
				((Component)val4).transform.position = val3;
				((Component)val4).gameObject.AddComponent<PvpSpikeFish>().DieAt = Time.time + 22f;
				try
				{
					AccessTools.Field(typeof(Creature), "_bossType").SetValue(val4, (object)(BossType)0);
				}
				catch
				{
				}
				try
				{
					AccessTools.Field(typeof(Item), "<LastPlayer>k__BackingField").SetValue(val4, shooter);
				}
				catch
				{
				}
				ShrinkIfHuge(val4);
				AimAtVictim(val4, val3, shooter);
				((NetworkBehaviour)instance).Spawn(((Component)val4).gameObject, (NetworkConnection)null, default(Scene));
				((Component)val4).transform.position = val3;
				KickFish(val4, val3, shooter);
				LiveFish.Add((Item)(object)val4);
			}
		}

		private static void ShrinkIfHuge(Creature spawned)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)spawned == (Object)null))
			{
				Vector3 lossyScale = ((Component)spawned).transform.lossyScale;
				float num = Mathf.Max(lossyScale.x, Mathf.Max(lossyScale.y, lossyScale.z));
				if (!(num <= 2.2f))
				{
					float num2 = 0.55f / num;
					((Component)spawned).transform.localScale = ((Component)spawned).transform.localScale * num2;
				}
			}
		}

		private static void AimAtVictim(Creature spawned, Vector3 pos, Player shooter)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Player val = PickVictim(pos, shooter);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			try
			{
				AccessTools.Field(typeof(Pufferfish), "_target").SetValue(spawned, val);
			}
			catch
			{
			}
			try
			{
				AccessTools.Field(typeof(AttackingFish), "_target").SetValue(spawned, val);
			}
			catch
			{
			}
		}

		private static void KickFish(Creature spawned, Vector3 pos, Player shooter)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)((Item)spawned).RigidbodySync != (Object)null)
				{
					((Item)spawned).RigidbodySync.SetKinematic(false);
					((Item)spawned).RigidbodySync.StartSimulateLocal(Vector3.zero, Quaternion.identity);
				}
				Rigidbody rig = ((Item)spawned).Rig;
				if (!((Object)(object)rig == (Object)null))
				{
					rig.isKinematic = false;
					rig.useGravity = true;
					Player val = PickVictim(pos, shooter);
					Vector3 val2 = Vector3.forward;
					if ((Object)(object)val != (Object)null && (Object)(object)val.Transform != (Object)null)
					{
						Vector3 val3 = val.Transform.position - pos;
						val2 = ((Vector3)(ref val3)).normalized;
					}
					rig.linearVelocity = val2 * 4.2f + Vector3.up * 2.4f;
					rig.angularVelocity = Random.insideUnitSphere * 8f;
				}
			}
			catch
			{
			}
		}

		private static Player PickVictim(Vector3 pos, Player shooter)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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)
			Player val = null;
			float num = float.MaxValue;
			try
			{
				List<Player> alivePlayers = PlayerManager.AlivePlayers;
				if (alivePlayers != null)
				{
					for (int i = 0; i < alivePlayers.Count; i++)
					{
						Player val2 = alivePlayers[i];
						if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2 == (Object)(object)shooter))
						{
							Vector3 val3;
							try
							{
								val3 = (((Object)(object)val2.Transform != (Object)null) ? val2.Transform.position : ((Component)val2).transform.position);
							}
							catch
							{
								continue;
							}
							Vector3 val4 = val3 - pos;
							float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
							if (sqrMagnitude < num)
							{
								num = sqrMagnitude;
								val = val2;
							}
						}
					}
				}
			}
			catch
			{
			}
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			try
			{
				return PlayerManager.GetNearestAlivePlayer(pos);
			}
			catch
			{
				return null;
			}
		}

		private static void PruneLive()
		{
			for (int num = LiveFish.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)LiveFish[num] == (Object)null)
				{
					LiveFish.RemoveAt(num);
				}
			}
		}

		private static bool IsSpike(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)item).GetComponent<PvpSpikeMark>() != (Object)null)
			{
				return true;
			}
			int num = IdOf(item);
			if (num != 0 && KnownIds.Contains(num))
			{
				return true;
			}
			Weapon val = (Weapon)(object)((item is Weapon) ? item : null);
			if ((Object)(object)val == (Object)null)
			{
				val = item.Weapon;
			}
			if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).GetComponent<PvpSpikeMark>() != (Object)null)
			{
				return true;
			}
			if (IsRifle(item))
			{
				return HasCoolSkin(item);
			}
			return false;
		}

		private static bool OwnerHoldingSpike(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			try
			{
				if ((Object)(object)player.Holding != (Object)null && IsSpike(player.Holding.HeldItem))
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				Dictionary<Transform, Item> items = ItemManager.Items;
				if (items != null)
				{
					foreach (KeyValuePair<Transform, Item> item in items)
					{
						Item value = item.Value;
						if (!((Object)(object)value == (Object)null) && IsSpike(value) && (Object)(object)value.Holder == (Object)(object)player)
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool IsRifle(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			string text = NameOf((Object)(object)item);
			if (text.IndexOf("packed") >= 0 || text.IndexOf("backup") >= 0)
			{
				return false;
			}
			if (text.IndexOf("assault") >= 0 || text.IndexOf("m4") >= 0)
			{
				return true;
			}
			if (text.IndexOf("rifle") >= 0)
			{
				return text.IndexOf("sniper") < 0;
			}
			return false;
		}

		private static bool HasCoolSkin(Item item)
		{
			//IL_0043: 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)
			if ((Object)(object)item == (Object)null || (Object)(object)item.SkinPreset == (Object)null)
			{
				return false;
			}
			try
			{
				IReadOnlyList<ItemSkin> skins = item.SkinPreset.Skins;
				int curSkin = item.CurSkin;
				if (skins == null || curSkin < 0 || curSkin >= skins.Count)
				{
					return false;
				}
				ItemSkin val = skins[curSkin];
				return SkinScore(((ItemSkin)(ref val)).Name) >= 80;
			}
			catch
			{
				return false;
			}
		}

		private static int CoolSkinIndex(Item item)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null || (Object)(object)item.SkinPreset == (Object)null)
			{
				return -1;
			}
			IReadOnlyList<ItemSkin> skins = item.SkinPreset.Skins;
			if (skins == null || skins.Count == 0)
			{
				return -1;
			}
			ItemSkin val;
			if (!_loggedSkins)
			{
				_loggedSkins = true;
				List<string> list = new List<string>();
				for (int i = 0; i < skins.Count; i++)
				{
					val = skins[i];
					list.Add(((ItemSkin)(ref val)).Name);
				}
				Debug.Log((object)("[HowToFishPvp] m4 skins: " + string.Join(", ", list.ToArray())));
			}
			int result = -1;
			int num = -1;
			for (int j = 0; j < skins.Count; j++)
			{
				val = skins[j];
				int num2 = SkinScore(((ItemSkin)(ref val)).Name);
				if (num2 > num)
				{
					num = num2;
					result = j;
				}
			}
			if (num > 0)
			{
				return result;
			}
			return skins.Count - 1;
		}

		private static int SkinScore(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return 0;
			}
			string text = name.ToLowerInvariant().Trim();
			if (text.IndexOf("diamond") >= 0)
			{
				return 100;
			}
			if (text.IndexOf("rainbow") >= 0)
			{
				return 92;
			}
			if (text.IndexOf("tiger") >= 0)
			{
				return 84;
			}
			if (text.IndexOf("hazard") >= 0)
			{
				return 76;
			}
			if (text.IndexOf("gold") >= 0)
			{
				return 70;
			}
			if (text.IndexOf("ruby") >= 0)
			{
				return 64;
			}
			if (text.IndexOf("pink") >= 0)
			{
				return 50;
			}
			if (text.IndexOf("emerald") >= 0)
			{
				return 40;
			}
			if (text.IndexOf("purple") >= 0 || text.IndexOf("violet") >= 0)
			{
				return 36;
			}
			if (text.IndexOf("blue fade") >= 0)
			{
				return 20;
			}
			if (text == "blue")
			{
				return 10;
			}
			return 0;
		}

		private static void EquipRedDot(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			try
			{
				Weapon val = (Weapon)(object)((item is Weapon) ? item : null);
				if ((Object)(object)val == (Object)null)
				{
					val = item.Weapon;
				}
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)item).GetComponentInChildren<Weapon>(true);
				}
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				Attachments attachments = val.Attachments;
				if ((Object)(object)attachments == (Object)null || !(AccessTools.Field(typeof(Attachments), "_sights").GetValue(attachments) is IList { Count: not 0 } list))
				{
					return;
				}
				int num = -1;
				int num2 = -1;
				for (int i = 0; i < list.Count; i++)
				{
					object? obj = list[i];
					Sight val2 = (Sight)((obj is Sight) ? obj : null);
					if (!((Object)(object)val2 == (Object)null))
					{
						int num3 = 0;
						if (val2 is RedDotSight)
						{
							num3 = 100;
						}
						string text = ((Object)val2).name.ToLowerInvariant();
						string text2 = InfoName(((Attachment)val2).Info);
						if (text.IndexOf("reddot") >= 0 || text.IndexOf("red dot") >= 0 || text2.IndexOf("reddot") >= 0 || text2.IndexOf("red dot") >= 0)
						{
							num3 = Math.Max(num3, 90);
						}
						if (num3 > num2)
						{
							num2 = num3;
							num = i;
						}
					}
				}
				if (num < 0)
				{
					return;
				}
				object? obj2 = list[num];
				Sight val3 = (Sight)((obj2 is Sight) ? obj2 : null);
				if ((Object)(object)val3 != (Object)null && (Object)(object)((Attachment)val3).Info != (Object)null)
				{
					try
					{
						if (!attachments.HasAttachment(((Attachment)val3).Info))
						{
							attachments.SetAttachment(((Attachment)val3).Info);
						}
						return;
					}
					catch
					{
						attachments._syncedSight.Value = (byte)num;
						return;
					}
				}
				attachments._syncedSight.Value = (byte)num;
			}
			catch
			{
			}
		}

		private static string InfoName(AttachmentInfo info)
		{
			if ((Object)(object)info == (Object)null)
			{
				return "";
			}
			try
			{
				return ((Object)info).name.ToLowerInvariant();
			}
			catch
			{
				return "";
			}
		}

		internal static Item RiflePrefab()
		{
			return GunPrefab();
		}

		private static Item GunPrefab()
		{
			if ((Object)(object)_gunPrefab != (Object)null)
			{
				return _gunPrefab;
			}
			Item val = null;
			int num = int.MinValue;
			foreach (Item item in AllItems())
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				string text = NameOf((Object)(object)item);
				if (text.IndexOf("packed") < 0 && text.IndexOf("backup") < 0 && text.IndexOf("attachment") < 0 && (!((Object)(object)item.Weapon == (Object)null) || item is Weapon))
				{
					int num2 = 0;
					if (text.IndexOf("assault") >= 0)
					{
						num2 = 220 - text.Length;
					}
					else if (text.IndexOf("m4a") >= 0)
					{
						num2 = 180;
					}
					else if (text.IndexOf("rifle") >= 0 && text.IndexOf("sniper") < 0)
					{
						num2 = 70 - text.Length;
					}
					if (num2 > num)
					{
						num = num2;
						val = item;
					}
				}
			}
			_gunPrefab = val;
			if ((Object)(object)val != (Object)null)
			{
				Debug.Log((object)("[HowToFishPvp] spike m4 prefab=" + ((Object)val).name));
			}
			return _gunPrefab;
		}

		private static Creature FishPrefab()
		{
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Invalid comparison between Unknown and I4
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Invalid comparison between Unknown and I4
			if ((Object)(object)_fishPrefab != (Object)null)
			{
				return _fishPrefab;
			}
			Creature val = null;
			int num = int.MinValue;
			foreach (Creature item in AllCreatures())
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				string text = NameOf((Object)(object)item);
				if (text.IndexOf("drip") >= 0 || text.IndexOf("meat") >= 0 || text.IndexOf("fin") >= 0)
				{
					continue;
				}
				int num2 = 0;
				if (text.IndexOf("seaurchin") >= 0 || text == "urchin")
				{
					num2 = 220;
				}
				else if (text.IndexOf("urchin") >= 0)
				{
					num2 = 200;
				}
				else if (text.IndexOf("puffer") >= 0 && text.IndexOf("npc") >= 0)
				{
					num2 = 130;
				}
				else if (text.IndexOf("puffer") >= 0)
				{
					num2 = 110;
				}
				else if (text.IndexOf("spike") >= 0)
				{
					num2 = 90;
				}
				if (item is Pufferfish)
				{
					num2 += 35;
				}
				try
				{
					if ((int)item.BossType == 2)
					{
						num2 -= 90;
					}
					else if ((int)item.BossType == 1)
					{
						num2 -= 25;
					}
				}
				catch
				{
				}
				if (num2 > num)
				{
					num = num2;
					val = item;
				}
			}
			_fishPrefab = val;
			if ((Object)(object)val != (Object)null)
			{
				Debug.Log((object)("[HowToFishPvp] spike fish prefab=" + ((Object)val).name));
			}
			return _fishPrefab;
		}

		private static List<Item> AllItems()
		{
			List<Item> list = new List<Item>();
			HashSet<int> hashSet = new HashSet<int>();
			TryAddDict(list, hashSet);
			try
			{
				Item[] array = Resources.LoadAll<Item>("Items");
				if (array != null)
				{
					for (int i = 0; i < array.Length; i++)
					{
						if (!((Object)(object)array[i] == (Object)null) && hashSet.Add(((Object)array[i]).GetInstanceID()))
						{
							list.Add(array[i]);
						}
					}
				}
			}
			catch
			{
			}
			return list;
		}

		private static void TryAddDict(List<Item> list, HashSet<int> seen)
		{
			try
			{
				if (AccessTools.Field(typeof(GameInfo), "_nameToSpawnable").GetValue(null) is Dictionary<string, Item> dictionary)
				{
					foreach (KeyValuePair<string, Item> item in dictionary)
					{
						if (!((Object)(object)item.Value == (Object)null) && seen.Add(((Object)item.Value).GetInstanceID()))
						{
							list.Add(item.Value);
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				if (!(AccessTools.Field(typeof(GameInfo), "_allItems").GetValue(null) is Dictionary<byte, Item> dictionary2))
				{
					return;
				}
				foreach (KeyValuePair<byte, Item> item2 in dictionary2)
				{
					if (!((Object)(object)item2.Value == (Object)null) && seen.Add(((Object)item2.Value).GetInstanceID()))
					{
						list.Add(item2.Value);
					}
				}
			}
			catch
			{
			}
		}

		private static List<Creature> AllCreatures()
		{
			List<Creature> list = new List<Creature>();
			HashSet<int> hashSet = new HashSet<int>();
			try
			{
				if (AccessTools.Field(typeof(GameInfo), "_allCreatures").GetValue(null) is List<Creature> list2)
				{
					for (int i = 0; i < list2.Count; i++)
					{
						if (!((Object)(object)list2[i] == (Object)null) && hashSet.Add(((Object)list2[i]).GetInstanceID()))
						{
							list.Add(list2[i]);
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Creature[] array = Resources.LoadAll<Creature>("Items/Creatures");
				if (array != null)
				{
					for (int j = 0; j < array.Length; j++)
					{
						if (!((Object)(object)array[j] == (Object)null) && hashSet.Add(((Object)array[j]).GetInstanceID()))
						{
							list.Add(array[j]);
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Item spawnable = GameInfo.GetSpawnable("SeaUrchin");
				if ((Object)(object)spawnable == (Object)null)
				{
					spawnable = GameInfo.GetSpawnable("Sea Urchin");
				}
				Creature val = (Creature)(object)((spawnable is Creature) ? spawnable : null);
				if ((Object)(object)val == (Object)null && (Object)(object)spawnable != (Object)null)
				{
					val = spawnable.Creature;
				}
				if ((Object)(object)val != (Object)null && hashSet.Add(((Object)val).GetInstanceID()))
				{
					list.Add(val);
				}
			}
			catch
			{
			}
			return list;
		}

		private static string NameOf(Object item)
		{
			if (item == (Object)null)
			{
				return "";
			}
			return item.name.Replace(" ", "").ToLowerInvariant();
		}

		private static void KickDown(Item spawned)
		{
			//IL_0060: 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)
			try
			{
				if ((Object)(object)spawned.RigidbodySync != (Object)null)
				{
					spawned.RigidbodySync.SetKinematic(false);
				}
				Rigidbody rig = spawned.Rig;
				if (!((Object)(object)rig == (Object)null))
				{
					rig.isKinematic = false;
					rig.useGravity = true;
					rig.linearDamping = 0.8f;
					rig.angularDamping = 0.9f;
					rig.linearVelocity = new Vector3(0f, -3.4f, 0f);
					rig.angularVelocity = Random.insideUnitSphere * 1.4f;
				}
			}
			catch
			{
			}
		}

		private static bool ParsePos(string data, out Vector3 pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			pos = Vector3.zero;
			if (string.IsNullOrEmpty(data))
			{
				return false;
			}
			string[] array = data.Split(new char[1] { ' ' });
			if (array.Length < 3)
			{
				return false;
			}
			if (!float.TryParse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			if (!float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				return false;
			}
			if (!float.TryParse(array[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
			{
				return false;
			}
			pos = new Vector3(result, result2, result3);
			return true;
		}

		private static Player PlayerBySteam(ulong steam)
		{
			if (steam == 0L)
			{
				return null;
			}
			Player[] array = Object.FindObjectsOfType<Player>(true);
			foreach (Player val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					if (val.SteamID == steam)
					{
						return val;
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private static bool IsHost()
		{
			if ((Object)(object)Server.Instance != (Object)null)
			{
				return ((NetworkBehaviour)Server.Instance).IsServerInitialized;
			}
			return false;
		}

		private static int IdOf(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return 0;
			}
			try
			{
				return ((NetworkBehaviour)item).ObjectId;
			}
			catch
			{
				return 0;
			}
		}

		private static Vector3 AimPoint(Player player)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			Transform val = null;
			try
			{
				if ((Object)(object)player != (Object)null)
				{
					val = player.CamObject;
				}
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				return Vector3.zero;
			}
			int num = -1;
			try
			{
				num = LayerMask.op_Implicit(GameInfo.ProjectileHitLayer);
			}
			catch
			{
			}
			RaycastHit val2 = default(RaycastHit);
			if (Physics.Raycast(val.position, val.forward, ref val2, 250f, num))
			{
				return ((RaycastHit)(ref val2)).point;
			}
			return val.position + val.forward * 80f;
		}

		[HarmonyPatch(typeof(BossManager), "InitializeBossFight")]
		[HarmonyPrefix]
		private static bool SkipBoss(Creature creature)
		{
			if (!((Object)(object)creature == (Object)null))
			{
				return (Object)(object)((Component)creature).GetComponent<PvpSpikeFish>() == (Object)null;
			}
			return true;
		}

		[HarmonyPatch(typeof(ProjectileManager), "Hit")]
		[HarmonyPostfix]
		private static void AfterHit(Projectile __0, RaycastHit __2)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (__0 != null && OwnerHoldingSpike(__0.Owner))
			{
				Request(((RaycastHit)(ref __2)).point, __0.Owner);
			}
		}

		[HarmonyPatch(typeof(ProjectileManager), "HitWater")]
		[HarmonyPostfix]
		private static void AfterWater(Projectile __0)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (__0 != null && OwnerHoldingSpike(__0.Owner))
			{
				Request(__0.Position, __0.Owner);
			}
		}

		[HarmonyPatch(typeof(Weapon), "Shoot")]
		[HarmonyPostfix]
		private static void AfterShoot(Weapon __instance)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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)
			if ((Object)(object)__instance == (Object)null || !IsSpike((Item)(object)__instance))
			{
				return;
			}
			Player val = null;
			try
			{
				val = ((Item)__instance).Holder;
			}
			catch
			{
			}
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val != (Object)(object)Player.LocalPlayer))
			{
				Vector3 pos = AimPoint(val);
				if (!(((Vector3)(ref pos)).sqrMagnitude < 0.01f))
				{
					Request(pos, val);
				}
			}
		}

		[HarmonyPatch(typeof(Weapon), "OnPickUp")]
		[HarmonyPostfix]
		private static void AfterPick(Weapon __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				int num = IdOf((Item)(object)__instance);
				if (num != 0 && KnownIds.Contains(num) && (Object)(object)((Component)__instance).GetComponent<PvpSpikeMark>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<PvpSpikeMark>();
				}
				if ((Object)(object)((Component)__instance).GetComponent<PvpSpikeMark>() != (Object)null || IsSpike((Item)(object)__instance))
				{
					DressGun((Item)(object)__instance);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class PvpSync
	{
		private const string Tag = "[PVP] ";

		private const string KeyFlag = "htf_pvp";

		private const string KeyState = "htf_st";

		private const string KeyScores = "htf_sc";

		private const string KeyGrab = "htf_g";

		private const string KeyArms = "htf_a";

		private const string KeyBoom = "htf_b";

		private const string KeySpike = "htf_f";

		private const string KeyCloak = "htf_c";

		private static string _lastWrite = "";

		private static float _nextWrite;

		private static readonly Dictionary<ulong, bool> LastCloak = new Dictionary<ulong, bool>();

		internal static void Tick()
		{
			PvpCloak.Tick();
			if (IsHost())
			{
				if (PvpSession.Queued)
				{
					WriteLobby();
					HostPollGrabs();
				}
			}
			else
			{
				ReadLobby();
				PvpBoom.StampMarks();
				PvpSpike.StampMarks();
				PvpCloak.StampMarks();
			}
		}

		internal static bool LobbySaysPvp()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (!TryLobby(out var lobby))
			{
				return false;
			}
			try
			{
				return SteamMatchmaking.GetLobbyData(lobby, "htf_pvp") == "1";
			}
			catch
			{
				return false;
			}
		}

		internal static void Send(string body)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				OnlineChatManager instance = OnlineChatManager.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				ulong num = 0uL;
				try
				{
					num = SteamManager.CurrentLobbyID.m_SteamID;
				}
				catch
				{
				}
				instance.SendChatMessage(num, "[PVP] " + body);
			}
			catch
			{
			}
			WriteLobby();
		}

		internal static bool TryApply(string message)
		{
			if (string.IsNullOrEmpty(message))
			{
				return false;
			}
			int num = message.IndexOf("[PVP] ");
			if (num < 0)
			{
				return false;
			}
			PvpSession.EnsureQueued();
			string rest = Strip(message.Substring(num + "[PVP] ".Length));
			PvpGrab.Hear(rest);
			if (IsHost())
			{
				PvpGrab.HostHear(rest);
				return true;
			}
			ApplyJoiner(rest);
			return true;
		}

		private static void WriteLobby()
		{
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			if (!TryLobby(out var lobby))
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			foreach (KeyValuePair<string, int> score in PvpSession.Scores)
			{
				if (stringBuilder.Length > 0)
				{
					stringBuilder.Append(';');
				}
				stringBuilder.Append(score.Key.Replace(";", "").Replace("=", ""));
				stringBuilder.Append('=');
				stringBuilder.Append(score.Value);
			}
			string[] obj = new string[15]
			{
				PvpSession.MatchRunning ? "1" : "0",
				",",
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null,
				null
			};
			int phase = (int)PvpSession.Phase;
			obj[2] = phase.ToString();
			obj[3] = ",";
			obj[4] = PvpSession.Round.ToString();
			obj[5] = ",";
			obj[6] = PvpSession.CountdownDisplay.ToString();
			obj[7] = ",";
			obj[8] = PvpSession.BalanceRound.ToString();
			obj[9] = ",";
			obj[10] = PvpSession.MapSeed.ToString();
			obj[11] = ",";
			obj[12] = PvpSession.FloodState.ToString();
			obj[13] = ",";
			obj[14] = PvpSession.SpectateSteam.ToString();
			string text = string.Concat(obj);
			string text2 = text + "|" + stringBuilder;
			if (text2 == _lastWrite && Time.unscaledTime < _nextWrite)
			{
				return;
			}
			_lastWrite = text2;
			_nextWrite = Time.unscaledTime + 1.25f;
			try
			{
				SteamMatchmaking.SetLobbyData(lobby, "htf_pvp", "1");
				SteamMatchmaking.SetLobbyData(lobby, "htf_st", text);
				SteamMatchmaking.SetLobbyData(lobby, "htf_sc", stringBuilder.ToString());
			}
			catch
			{
			}
		}

		private static void ReadLobby()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			if (!TryLobby(out var lobby))
			{
				return;
			}
			string lobbyData;
			try
			{
				lobbyData = SteamMatchmaking.GetLobbyData(lobby, "htf_pvp");
			}
			catch
			{
				return;
			}
			if (lobbyData != "1")
			{
				return;
			}
			bool num = !PvpSession.Queued;
			PvpSession.EnsureQueued();
			if (num)
			{
				Debug.Log((object)"[HowToFishPvp] Joiner PVP from Steam lobby data");
			}
			string lobbyData2 = SteamMatchmaking.GetLobbyData(lobby, "htf_st");
			if (!string.IsNullOrEmpty(lobbyData2))
			{
				string[] array = lobbyData2.Split(new char[1] { ',' });
				if (array.Length >= 4)
				{
					PvpSession.MatchRunning = array[0] == "1";
					if (int.TryParse(array[1], out var result) && result >= 0 && result <= 5)
					{
						PvpSession.Phase = (PvpPhase)result;
					}
					if (int.TryParse(array[2], out var result2))
					{
						PvpSession.Round = result2;
					}
					if (int.TryParse(array[3], out var result3))
					{
						PvpSession.CountdownDisplay = result3;
					}
					if (array.Length >= 5 && int.TryParse(array[4], out var result4))
					{
						PvpSession.BalanceRound = result4;
					}
					if (array.Length >= 6 && int.TryParse(array[5], out var result5) && result5 != 0)
					{
						PvpSession.MapSeed = result5;
						PvpArena.Roll(result5);
					}
					if (array.Length >= 7 && int.TryParse(array[6], out var result6))
					{
						PvpSession.FloodState = result6;
					}
					if (array.Length >= 8 && ulong.TryParse(array[7], out var result7))
					{
						PvpSession.SpectateSteam = result7;
					}
				}
			}
			string lobbyData3 = SteamMatchmaking.GetLobbyData(lobby, "htf_sc");
			if (string.IsNullOrEmpty(lobbyData3))
			{
				return;
			}
			string[] array2 = lobbyData3.Split(new char[1] { ';' });
			for (int i = 0; i < array2.Length; i++)
			{
				int num2 = array2[i].LastIndexOf('=');
				if (num2 > 0)
				{
					string text = array2[i].Substring(0, num2);
					if (int.TryParse(array2[i].Substring(num2 + 1), out var result8))
					{
						PvpSession.Scores[text] = result8;
						PvpSession.Names[text] = text;
					}
				}
			}
		}

		internal static void SetMemberGrab(string grab, string arms)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!TryLobby(out var lobby))
			{
				return;
			}
			try
			{
				SteamMatchmaking.SetLobbyMemberData(lobby, "htf_g", grab ?? "");
				SteamMatchmaking.SetLobbyMemberData(lobby, "htf_a", arms ?? "");
			}
			catch
			{
			}
		}

		internal static void SetMemberBoom(string body)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!TryLobby(out var lobby))
			{
				return;
			}
			try
			{
				SteamMatchmaking.SetLobbyMemberData(lobby, "htf_b", body ?? "");
			}
			catch
			{
			}
		}

		internal static void SetMemberSpike(string body)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!TryLobby(out var lobby))
			{
				return;
			}
			try
			{
				SteamMatchmaking.SetLobbyMemberData(lobby, "htf_f", body ?? "");
			}
			catch
			{
			}
		}

		internal static void SetMemberCloak(string body)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!TryLobby(out var lobby))
			{
				return;
			}
			try
			{
				SteamMatchmaking.SetLobbyMemberData(lobby, "htf_c", body ?? "");
			}
			catch
			{
			}
		}

		internal static void PollCloaks()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			if (!TryLobby(out var lobby))
			{
				return;
			}
			CSteamID steamID;
			try
			{
				steamID = SteamUser.GetSteamID();
			}
			catch
			{
				return;
			}
			int numLobbyMembers;
			try
			{
				numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobby);
			}
			catch
			{
				return;
			}
			for (int i = 0; i < numLobbyMembers; i++)
			{
				CSteamID lobbyMemberByIndex;
				try
				{
					lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(lobby, i);
				}
				catch
				{
					continue;
				}
				if (!(lobbyMemberByIndex == steamID))
				{
					string text = "";
					try
					{
						text = SteamMatchmaking.GetLobbyMemberData(lobby, lobbyMemberByIndex, "htf_c");
					}
					catch
					{
						continue;
					}
					bool flag = !string.IsNullOrEmpty(text) && text[0] == '1';
					PvpCloak.HearCloak(lobbyMemberByIndex.m_SteamID, flag);
					if (IsHost())
					{
						RelayCloak(lobbyMemberByIndex.m_SteamID, flag);
					}
				}
			}
		}

		private static void RelayCloak(ulong steam, bool on)
		{
			if (!LastCloak.TryGetValue(steam, out var value) || value != on)
			{
				LastCloak[steam] = on;
				Send("cloak " + steam + " " + (on ? "1" : "0"));
			}
		}

		private static void HostPollGrabs()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			if (!TryLobby(out var lobby))
			{
				return;
			}
			CSteamID steamID;
			try
			{
				steamID = SteamUser.GetSteamID();
			}
			catch
			{
				return;
			}
			int numLobbyMembers;
			try
			{
				numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(lobby);
			}
			catch
			{
				return;
			}
			for (int i = 0; i < numLobbyMembers; i++)
			{
				CSteamID lobbyMemberByIndex;
				try
				{
					lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(lobby, i);
				}
				catch
				{
					continue;
				}
				if (!(lobbyMemberByIndex == steamID))
				{
					string text = "";
					string text2 = "";
					string text3 = "";
					string text4 = "";
					try
					{
						text = SteamMatchmaking.GetLobbyMemberData(lobby, lobbyMemberByIndex, "htf_g");
						text2 = SteamMatchmaking.GetLobbyMemberData(lobby, lobbyMemberByIndex, "htf_a");
						text3 = SteamMatchmaking.GetLobbyMemberData(lobby, lobbyMemberByIndex, "htf_b");
						text4 = SteamMatchmaking.GetLobbyMemberData(lobby, lobbyMemberByIndex, "htf_f");
					}
					catch
					{
						continue;
					}
					if (!string.IsNullOrEmpty(text2))
					{
						PvpGrab.Hear("a " + text2);
					}
					if (!string.IsNullOrEmpty(text))
					{
						PvpGrab.HostHear("g " + text);
					}
					if (!string.IsNullOrEmpty(text3))
					{
						PvpBoom.HearFrom(lobbyMemberByIndex.m_SteamID, text3);
					}
					if (!string.IsNullOrEmpty(text4))
					{
						PvpSpike.HearFrom(lobbyMemberByIndex.m_SteamID, text4);
					}
				}
			}
		}

		private static bool TryLobby(out CSteamID lobby)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			lobby = CSteamID.Nil;
			try
			{
				lobby = SteamManager.CurrentLobbyID;
			}
			catch
			{
				return false;
			}
			return lobby.m_SteamID != 0;
		}

		private static string Strip(string rest)
		{
			rest = rest.Trim();
			int num = rest.IndexOf('<');
			if (num >= 0)
			{
				rest = rest.Substring(0, num).Trim();
			}
			return rest;
		}

		private static void ApplyJoiner(string rest)
		{
			if (rest.StartsWith("waiting", StringComparison.OrdinalIgnoreCase))
			{
				PvpSession.MatchRunning = false;
				if (PvpSession.Phase != PvpPhase.MatchOver)
				{
					PvpSession.Phase = PvpPhase.WaitingForPlayers;
				}
				PvpSession.CountdownDisplay = -1;
				return;
			}
			switch (rest)
			{
			case "3":
			case "2":
			case "1":
			{
				if (int.TryParse(rest, out var result))
				{
					PvpSession.CountdownDisplay = result;
				}
				PvpSession.MatchRunning = true;
				PvpSession.Phase = PvpPhase.Countdown;
				return;
			}
			}
			if (string.Equals(rest, "GO", StringComparison.OrdinalIgnoreCase))
			{
				PvpSession.CountdownDisplay = 0;
				PvpSession.MatchRunning = true;
				PvpSession.Phase = PvpPhase.Fighting;
				PvpController.RestoreAllViews();
				return;
			}
			if (rest.IndexOf("Round ", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				PvpSession.MatchRunning = true;
				PvpSession.Phase = PvpPhase.Countdown;
				PvpSession.CountdownDisplay = -1;
				PvpController.RestoreAllViews();
				int num = rest.IndexOf("Round ", StringComparison.OrdinalIgnoreCase);
				string text = rest.Substring(num + 6);
				int num2 = text.IndexOf('/');
				if (int.TryParse(((num2 >= 0) ? text.Substring(0, num2) : text).Trim(), out var result2))
				{
					PvpSession.Round = result2;
				}
				return;
			}
			int num3 = rest.IndexOf(" wins round ", StringComparison.OrdinalIgnoreCase);
			if (num3 > 0)
			{
				AwardByName(rest.Substring(0, num3));
				PvpSession.Phase = PvpPhase.RoundOver;
				PvpSession.CountdownDisplay = -1;
				return;
			}
			if (rest.StartsWith("boomgun ", StringComparison.OrdinalIgnoreCase))
			{
				if (int.TryParse(rest.Substring(8).Trim(), out var result3))
				{
					PvpBoom.HearGunId(result3);
				}
				return;
			}
			if (rest.StartsWith("spikegun ", StringComparison.OrdinalIgnoreCase))
			{
				if (int.TryParse(rest.Substring(9).Trim(), out var result4))
				{
					PvpSpike.HearGunId(result4);
				}
				return;
			}
			if (rest.StartsWith("knifegun ", StringComparison.OrdinalIgnoreCase))
			{
				if (int.TryParse(rest.Substring(9).Trim(), out var result5))
				{
					PvpCloak.HearGunId(result5);
				}
				return;
			}
			if (rest.StartsWith("cloak ", StringComparison.OrdinalIgnoreCase))
			{
				string[] array = rest.Split(new char[1] { ' ' });
				if (array.Length >= 3 && ulong.TryParse(array[1], out var result6))
				{
					PvpCloak.HearCloak(result6, array[2] == "1");
				}
				return;
			}
			if (string.Equals(rest, "mythic", StringComparison.OrdinalIgnoreCase))
			{
				PvpBoom.PlayMythicCatch();
				return;
			}
			if (string.Equals(rest, "floodwarn", StringComparison.OrdinalIgnoreCase))
			{
				PvpSession.FloodState = 1;
				PvpSession.CenterBanner = "WATER WILL RISE";
				PvpSession.Phase = PvpPhase.Fighting;
				return;
			}
			if (string.Equals(rest, "floodrise", StringComparison.OrdinalIgnoreCase))
			{
				PvpSession.FloodState = 2;
				PvpSession.CenterBanner = "";
				PvpSession.Phase = PvpPhase.Fighting;
				return;
			}
			if (string.Equals(rest, "newmatch", StringComparison.OrdinalIgnoreCase))
			{
				PvpSession.Scores.Clear();
				PvpSession.Round = 0;
				PvpSession.FloodState = 0;
				PvpSession.CenterBanner = "";
				PvpSession.SpectateSteam = 0uL;
				PvpSession.MatchRunning = true;
				PvpSession.Phase = PvpPhase.WaitingForPlayers;
				PvpWinnerCam.Stop();
				PvpFlood.Restore();
				return;
			}
			if (!rest.StartsWith("winner ", StringComparison.OrdinalIgnoreCase))
			{
				return;
			}
			PvpSession.MatchRunning = true;
			PvpSession.Phase = PvpPhase.MatchOver;
			PvpSession.CountdownDisplay = -1;
			string text2 = rest.Substring(7).Trim();
			int num4 = text2.IndexOf(' ');
			string s = ((num4 >= 0) ? text2.Substring(0, num4) : text2);
			string text3 = ((num4 >= 0) ? text2.Substring(num4 + 1).Trim() : "");
			ulong.TryParse(s, out var result7);
			PvpSession.SpectateSteam = result7;
			PvpSession.CenterBanner = (string.IsNullOrEmpty(text3) ? "WINNER" : ("WINNER\n" + text3));
			Player winner = null;
			if (PlayerManager.Players != null)
			{
				foreach (Player player in PlayerManager.Players)
				{
					if ((Object)(object)player == (Object)null)
					{
						continue;
					}
					try
					{
						if (result7 != 0L && player.SteamID == result7)
						{
							winner = player;
							break;
						}
					}
					catch
					{
					}
				}
			}
			PvpWinnerCam.Start(winner);
			if (result7 != 0L)
			{
				PvpSession.SpectateSteam = result7;
			}
			if (!string.IsNullOrEmpty(text3))
			{
				PvpSession.CenterBanner = "WINNER\n" + text3;
			}
		}

		private static void AwardByName(string name)
		{
			if (string.IsNullOrEmpty(name) || PlayerManager.Players == null)
			{
				return;
			}
			foreach (Player player in PlayerManager.Players)
			{
				if (!((Object)(object)player == (Object)null) && string.Equals(player.SteamName, name, StringComparison.OrdinalIgnoreCase))
				{
					PvpSession.AwardRound(player);
					return;
				}
			}
			if (!PvpSession.Scores.ContainsKey(name))
			{
				PvpSession.Scores[name] = 0;
			}
			PvpSession.Names[name] = name;
			PvpSession.Scores[name] = PvpSession.Scores[name] + 1;
		}

		private static bool IsHost()
		{
			if ((Object)(object)Server.Instance != (Object)null)
			{
				return ((NetworkBehaviour)Server.Instance).IsServerInitialized;
			}
			return false;
		}

		[HarmonyPatch(typeof(ChatManager), "ChatMessage", new Type[] { typeof(string) })]
		[HarmonyPrefix]
		private static bool OnChat(string message)
		{
			if (!TryApply(message))
			{
				return true;
			}
			string text = Strip(message.Substring(message.IndexOf("[PVP] ") + "[PVP] ".Length));
			if (text.StartsWith("waiting", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			switch (text)
			{
			case "3":
			case "2":
			case "1":
			case "GO":
				return false;
			default:
				if (string.Equals(text, "floodwarn", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "floodrise", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "newmatch", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "mythic", StringComparison.OrdinalIgnoreCase) || text.StartsWith("boomgun ", StringComparison.OrdinalIgnoreCase) || text.StartsWith("spikegun ", StringComparison.OrdinalIgnoreCase) || text.StartsWith("knifegun ", StringComparison.OrdinalIgnoreCase) || text.StartsWith("cloak ", StringComparison.OrdinalIgnoreCase) || text.StartsWith("winner ", StringComparison.OrdinalIgnoreCase))
				{
					return false;
				}
				if (PvpGrab.HideChat(text))
				{
					return false;
				}
				return true;
			}
		}
	}
	[HarmonyPatch]
	internal static class ShopPatch
	{
		[HarmonyPatch(typeof(ItemPurchasable), "Interact")]
		[HarmonyPrefix]
		private static bool BlockItemShop()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPatch(typeof(BulletPurchasable), "Interact")]
		[HarmonyPrefix]
		private static bool BlockBulletShop()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPatch(typeof(AttachmentPurchasable), "Interact")]
		[HarmonyPrefix]
		private static bool BlockAttachmentShop()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPatch(typeof(Server), "RpcLogic___BuyItem___4197152275")]
		[HarmonyPrefix]
		private static bool BlockBuy()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPatch(typeof(BoatInteractable), "Interact")]
		[HarmonyPrefix]
		private static bool BlockBoatDrive()
		{
			if (!PvpSession.Queued)
			{
				return true;
			}
			return PvpBoats.IsRound;
		}

		[HarmonyPatch(typeof(NPCInteractable), "Interact")]
		[HarmonyPrefix]
		private static bool BlockNpcTalk()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPatch(typeof(NPC), "OnInteract")]
		[HarmonyPrefix]
		private static bool BlockNpcOnInteract()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPatch(typeof(QuestInteractable), "Interact")]
		[HarmonyPrefix]
		private static bool BlockNpcQuest()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPatch(typeof(BetButton), "Interact")]
		[HarmonyPrefix]
		private static bool BlockBetButton()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPatch(typeof(SlotMachineManager), "RollRandom")]
		[HarmonyPrefix]
		private static bool BlockSlotRoll()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPatch(typeof(Server), "RpcLogic___PlaceBet___1246646286")]
		[HarmonyPrefix]
		private static bool BlockPlaceBet()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPatch(typeof(Server), "RpcLogic___ClientSpokeToNpc___1246646286")]
		[HarmonyPrefix]
		private static bool BlockSpokeToNpc()
		{
			return !PvpSession.Queued;
		}

		[HarmonyPatch(typeof(Server), "RpcLogic___TakeItemFromNpc___1382779195")]
		[HarmonyPrefix]
		private static bool BlockTakeFromNpc()
		{
			return !PvpSession.Queued;
		}
	}
}