using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Peak;
using Peak.Afflictions;
using Photon.Pun;
using Photon.Realtime;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Zorro.Core;
using Zorro.Core.Serizalization;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("PeakVs")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("PeakVs")]
[assembly: AssemblyTitle("PeakVs")]
[assembly: AssemblyVersion("1.0.0.0")]
[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 PeakVs
{
	internal static class GameMode
	{
		private static int _cachedFrame = int.MinValue;

		private static bool _cachedIsGameplayScene;

		private static bool _cachedLobbyCompatible;

		private static bool _cachedIsActive;

		private static float _nextPresencePublish;

		internal static bool IsGameplayScene
		{
			get
			{
				RefreshFrameCache();
				return _cachedIsGameplayScene;
			}
		}

		internal static bool AllPlayersCompatible
		{
			get
			{
				RefreshFrameCache();
				return _cachedLobbyCompatible;
			}
		}

		internal static bool IsActive
		{
			get
			{
				RefreshFrameCache();
				return _cachedIsActive;
			}
		}

		internal static void TickPresence()
		{
			//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_007b: Expected O, but got Unknown
			//IL_0082: Expected O, but got Unknown
			object value;
			if (!PhotonNetwork.InRoom || PhotonNetwork.LocalPlayer == null)
			{
				_nextPresencePublish = 0f;
			}
			else if ((!((Dictionary<object, object>)(object)PhotonNetwork.LocalPlayer.CustomProperties).TryGetValue((object)"pvs.v", out value) || !(Convert.ToString(value) == "0.7.2")) && !(Time.unscaledTime < _nextPresencePublish))
			{
				_nextPresencePublish = Time.unscaledTime + 2f;
				Player localPlayer = PhotonNetwork.LocalPlayer;
				Hashtable val = new Hashtable();
				((Dictionary<object, object>)val).Add((object)"pvs.v", (object)"0.7.2");
				localPlayer.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
				_cachedFrame = int.MinValue;
			}
		}

		internal static void ClearPresence()
		{
			//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_0026: Expected O, but got Unknown
			//IL_002d: Expected O, but got Unknown
			try
			{
				if (PhotonNetwork.InRoom && PhotonNetwork.LocalPlayer != null)
				{
					Player localPlayer = PhotonNetwork.LocalPlayer;
					Hashtable val = new Hashtable();
					((Dictionary<object, object>)val).Add((object)"pvs.v", (object)null);
					localPlayer.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
					_cachedFrame = int.MinValue;
				}
			}
			catch
			{
			}
		}

		private static void RefreshFrameCache()
		{
			int frameCount = Time.frameCount;
			if (_cachedFrame == frameCount)
			{
				return;
			}
			_cachedFrame = frameCount;
			try
			{
				_cachedIsGameplayScene = PhotonNetwork.InRoom && (Object)(object)Character.localCharacter != (Object)null && !Character.localCharacter.inAirport && MapHandler.Exists;
				_cachedLobbyCompatible = HasCompatiblePlayers();
				_cachedIsActive = _cachedIsGameplayScene && _cachedLobbyCompatible;
			}
			catch
			{
				_cachedIsGameplayScene = false;
				_cachedLobbyCompatible = false;
				_cachedIsActive = false;
			}
		}

		private static bool HasCompatiblePlayers()
		{
			if (!PhotonNetwork.InRoom || PhotonNetwork.CurrentRoom == null)
			{
				return false;
			}
			int num = 0;
			foreach (Player value2 in PhotonNetwork.CurrentRoom.Players.Values)
			{
				if (value2 != null && !value2.IsInactive)
				{
					num++;
					if (!((Dictionary<object, object>)(object)value2.CustomProperties).TryGetValue((object)"pvs.v", out object value) || Convert.ToString(value) != "0.7.2")
					{
						return false;
					}
				}
			}
			return num > 0;
		}
	}
	internal sealed class PeakVsMenuWindow : MenuWindow
	{
		internal Selectable StartingSelection;

		public override bool openOnStart => false;

		public override bool selectOnOpen => true;

		public override Selectable objectToSelectOnOpen => StartingSelection;

		public override bool closeOnPause => true;

		public override bool closeOnUICancel => true;

		public override bool blocksPlayerInput => true;

		public override bool showCursorWhileOpen => true;

		public override bool autoHideOnClose => true;
	}
	internal static class HostMenu
	{
		private sealed class MenuRow
		{
			internal GameObject Root;

			internal Image Background;

			internal Button Button;

			internal TextMeshProUGUI Label;

			internal TextMeshProUGUI Value;
		}

		private static readonly MethodInfo OpenMethod = AccessTools.Method(typeof(MenuWindow), "Open", (Type[])null, (Type[])null);

		private static readonly MethodInfo CloseMethod = AccessTools.Method(typeof(MenuWindow), "Close", (Type[])null, (Type[])null);

		private static readonly MethodInfo StartClosedMethod = AccessTools.Method(typeof(MenuWindow), "StartClosed", (Type[])null, (Type[])null);

		private static Canvas _canvas;

		private static RectTransform _panel;

		private static PeakVsMenuWindow _window;

		private static TextMeshProUGUI _title;

		private static TextMeshProUGUI _subtitle;

		private static TextMeshProUGUI _hostHeading;

		private static TextMeshProUGUI _status;

		private static TextMeshProUGUI _hint;

		private static MenuRow _showHud;

		private static MenuRow _hudScale;

		private static MenuRow _rivalOpacity;

		private static MenuRow _menuHotkey;

		private static MenuRow _compactHotkey;

		private static MenuRow _autoAdvance;

		private static MenuRow _matchedLoot;

		private static MenuRow _restartSplit;

		private static MenuRow _forceCheckpoint;

		private static MenuRow _close;

		private static float _nextRefresh;

		private static int _lastFontRevision = -1;

		private static ConfigEntry<KeyCode> _captureTarget;

		private static MenuRow _captureRow;

		private static int _captureStartFrame;

		internal static void Initialize()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_009f: 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_00d8: 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_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)
			//IL_0128: 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_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: 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_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_044a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04de: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0519: Unknown result type (might be due to invalid IL or missing references)
			//IL_051e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_canvas != (Object)null))
			{
				_canvas = PeakVsUi.CreateCanvas("PeakVs Menu Canvas", 32760, interactive: true);
				Image obj = PeakVsUi.CreateImage(((Component)_canvas).transform, "PeakVs Menu", new Color(0f, 0f, 0f, 0.48f));
				((Graphic)obj).raycastTarget = true;
				PeakVsUi.SetRect(((Graphic)obj).rectTransform, Vector2.zero, Vector2.one, new Vector2(0.5f, 0.5f), Vector2.zero, Vector2.zero);
				_window = ((Component)obj).gameObject.AddComponent<PeakVsMenuWindow>();
				Image obj2 = PeakVsUi.CreateImage(((Component)obj).transform, "Panel", PeakVsUi.PanelColor);
				((Graphic)obj2).raycastTarget = true;
				_panel = ((Graphic)obj2).rectTransform;
				PeakVsUi.SetRect(_panel, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, new Vector2(680f, 814f));
				PeakVsUi.SetRect(((Graphic)PeakVsUi.CreateImage((Transform)(object)_panel, "Accent", PeakVsUi.AccentColor)).rectTransform, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0.5f, 1f), Vector2.zero, new Vector2(0f, 5f));
				_title = PeakVsUi.CreateText((Transform)(object)_panel, "Title", 34f, (TextAlignmentOptions)4097, PeakVsUi.TextColor);
				((TMP_Text)_title).fontStyle = (FontStyles)1;
				((TMP_Text)_title).text = "PEAK VS";
				Place(((TMP_Text)_title).rectTransform, -24f, 44f);
				_subtitle = PeakVsUi.CreateText((Transform)(object)_panel, "Role", 18f, (TextAlignmentOptions)4100, PeakVsUi.MutedColor);
				Place(((TMP_Text)_subtitle).rectTransform, -30f, 34f);
				TextMeshProUGUI obj3 = PeakVsUi.CreateText((Transform)(object)_panel, "Display Heading", 17f, (TextAlignmentOptions)4097, PeakVsUi.AccentColor);
				((TMP_Text)obj3).text = "LOCAL DISPLAY";
				Place(((TMP_Text)obj3).rectTransform, -82f, 28f);
				_showHud = CreateRow("Show Race HUD", -116f, ToggleHud);
				_hudScale = CreateRow("HUD Scale", -172f, CycleHudScale);
				_rivalOpacity = CreateRow("Rival Opacity", -228f, CycleRivalOpacity);
				_menuHotkey = CreateRow("Menu Hotkey", -284f, delegate
				{
					BeginKeyCapture(_menuHotkey, PeakVsPlugin.MenuToggleKey);
				});
				_compactHotkey = CreateRow("Compact HUD Hotkey", -340f, delegate
				{
					BeginKeyCapture(_compactHotkey, PeakVsPlugin.CompactHudToggleKey);
				});
				_hostHeading = PeakVsUi.CreateText((Transform)(object)_panel, "Host Heading", 17f, (TextAlignmentOptions)4097, PeakVsUi.WarmColor);
				((TMP_Text)_hostHeading).text = "HOST RACE CONTROLS";
				Place(((TMP_Text)_hostHeading).rectTransform, -404f, 28f);
				_autoAdvance = CreateRow("Auto Advance", -438f, ToggleAutoAdvance);
				_matchedLoot = CreateRow("Matched Luggage Loot", -494f, ToggleMatchedLoot);
				_restartSplit = CreateRow("Restart Current Split", -550f, RestartSplit, centered: true);
				_forceCheckpoint = CreateRow("Force Checkpoint", -606f, ForceCheckpoint, centered: true);
				_status = PeakVsUi.CreateText((Transform)(object)_panel, "Status", 17f, (TextAlignmentOptions)514, PeakVsUi.MutedColor);
				Place(((TMP_Text)_status).rectTransform, -672f, 30f);
				_close = CreateRow("CLOSE", -716f, Close, centered: true);
				((TMP_Text)_close.Label).alignment = (TextAlignmentOptions)514;
				((Graphic)_close.Label).color = PeakVsUi.AccentColor;
				_hint = PeakVsUi.CreateText((Transform)(object)_panel, "Hint", 14f, (TextAlignmentOptions)514, PeakVsUi.MutedColor);
				((TMP_Text)_hint).text = ((object)PeakVsPlugin.MenuToggleKey.Value/*cast due to .constrained prefix*/).ToString().ToUpperInvariant() + " MENU  /  " + ((object)PeakVsPlugin.CompactHudToggleKey.Value/*cast due to .constrained prefix*/).ToString().ToUpperInvariant() + " COMPACT HUD  /  ESC CLOSE";
				Place(((TMP_Text)_hint).rectTransform, -775f, 24f);
				_window.StartingSelection = (Selectable)(object)_showHud.Button;
				StartClosedMethod.Invoke(_window, null);
				Refresh(forceFont: true);
			}
		}

		internal static void Tick()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_canvas == (Object)null)
			{
				Initialize();
			}
			if (((MenuWindow)_window).isOpen && _captureTarget != null)
			{
				CaptureHotkey();
				return;
			}
			if (Input.GetKeyDown(PeakVsPlugin.MenuToggleKey.Value))
			{
				if (((MenuWindow)_window).isOpen)
				{
					Close();
				}
				else
				{
					Refresh(forceFont: true);
					OpenMethod.Invoke(_window, null);
				}
			}
			if (((MenuWindow)_window).isOpen && Time.unscaledTime >= _nextRefresh)
			{
				_nextRefresh = Time.unscaledTime + 0.5f;
				Refresh(forceFont: false);
			}
		}

		internal static void Dispose()
		{
			if ((Object)(object)_canvas != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_canvas).gameObject);
			}
			_canvas = null;
			_panel = null;
			_window = null;
			_lastFontRevision = -1;
			_captureTarget = null;
			_captureRow = null;
		}

		private static MenuRow CreateRow(string labelText, float y, Action action, bool centered = false)
		{
			//IL_0013: 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_0044: 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_005e: 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_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_00ba: 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_00fa: 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_0131: 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_014e: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: 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_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: 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_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			Image val = PeakVsUi.CreateImage((Transform)(object)_panel, labelText, PeakVsUi.RowColor);
			((Graphic)val).raycastTarget = true;
			PeakVsUi.SetRect(((Graphic)val).rectTransform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), new Vector2(620f, 48f));
			Button val2 = ((Component)val).gameObject.AddComponent<Button>();
			((Selectable)val2).targetGraphic = (Graphic)(object)val;
			((Selectable)val2).transition = (Transition)1;
			ColorBlock colors = ((Selectable)val2).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.82f, 0.96f, 1f, 1f);
			((ColorBlock)(ref colors)).selectedColor = new Color(0.72f, 0.94f, 1f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.48f, 0.83f, 0.9f, 1f);
			((ColorBlock)(ref colors)).disabledColor = new Color(0.34f, 0.38f, 0.4f, 0.65f);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((Selectable)val2).colors = colors;
			((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
			{
				action();
				Refresh(forceFont: true);
			});
			TextMeshProUGUI val3 = PeakVsUi.CreateText(((Component)val).transform, "Label", 20f, (TextAlignmentOptions)(centered ? 514 : 4097), PeakVsUi.TextColor);
			PeakVsUi.SetRect(((TMP_Text)val3).rectTransform, (Vector2)(centered ? Vector2.zero : new Vector2(0f, 0.5f)), (Vector2)(centered ? Vector2.one : new Vector2(0f, 0.5f)), centered ? new Vector2(0.5f, 0.5f) : new Vector2(0f, 0.5f), (Vector2)(centered ? Vector2.zero : new Vector2(20f, 0f)), (Vector2)(centered ? Vector2.zero : new Vector2(370f, 42f)));
			((TMP_Text)val3).text = labelText;
			TextMeshProUGUI val4 = PeakVsUi.CreateText(((Component)val).transform, "Value", 20f, (TextAlignmentOptions)4100, PeakVsUi.AccentColor);
			PeakVsUi.SetRect(((TMP_Text)val4).rectTransform, new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(1f, 0.5f), new Vector2(-20f, 0f), new Vector2(260f, 0f));
			((Component)val4).gameObject.SetActive(!centered);
			return new MenuRow
			{
				Root = ((Component)val).gameObject,
				Background = val,
				Button = val2,
				Label = val3,
				Value = val4
			};
		}

		private static void Place(RectTransform rect, float y, float height)
		{
			//IL_000b: 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_0029: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			PeakVsUi.SetRect(rect, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, y), new Vector2(620f, height));
		}

		private static void Refresh(bool forceFont)
		{
			//IL_0046: 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_00ed: 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_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_01f0: 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_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0511: Unknown result type (might be due to invalid IL or missing references)
			//IL_0516: Unknown result type (might be due to invalid IL or missing references)
			//IL_0534: Unknown result type (might be due to invalid IL or missing references)
			//IL_0539: Unknown result type (might be due to invalid IL or missing references)
			bool flag = PhotonNetwork.IsConnected && PhotonNetwork.IsMasterClient;
			((TMP_Text)_subtitle).text = (flag ? "HOST" : (PhotonNetwork.IsConnected ? "RACER" : "NOT IN A LOBBY"));
			((Graphic)_subtitle).color = (flag ? PeakVsUi.WarmColor : PeakVsUi.MutedColor);
			((TMP_Text)_showHud.Value).text = (PeakVsPlugin.ShowRaceHud.Value ? "ON" : "OFF");
			((TMP_Text)_hudScale.Value).text = $"{PeakVsPlugin.HudScale.Value:0.0}×";
			((TMP_Text)_rivalOpacity.Value).text = $"{Mathf.RoundToInt(PeakVsPlugin.RemoteScoutOpacity.Value * 100f)}%";
			((TMP_Text)_menuHotkey.Value).text = ((_captureTarget == PeakVsPlugin.MenuToggleKey) ? "PRESS A KEY" : ((object)PeakVsPlugin.MenuToggleKey.Value/*cast due to .constrained prefix*/).ToString().ToUpperInvariant());
			((TMP_Text)_compactHotkey.Value).text = ((_captureTarget == PeakVsPlugin.CompactHudToggleKey) ? "PRESS A KEY" : ((object)PeakVsPlugin.CompactHudToggleKey.Value/*cast due to .constrained prefix*/).ToString().ToUpperInvariant());
			((TMP_Text)_autoAdvance.Value).text = (PeakVsPlugin.AutoLightCheckpoints.Value ? "ON" : "OFF");
			((TMP_Text)_matchedLoot.Value).text = (RaceSession.SameLuggageLoot ? "SAME" : "INDEPENDENT");
			SetToggleStyle(_showHud, PeakVsPlugin.ShowRaceHud.Value);
			SetToggleStyle(_autoAdvance, PeakVsPlugin.AutoLightCheckpoints.Value);
			SetToggleStyle(_matchedLoot, RaceSession.SameLuggageLoot);
			((Graphic)_hudScale.Background).color = new Color(0.12f, 0.18f, 0.22f, 0.96f);
			((Graphic)_rivalOpacity.Background).color = new Color(0.12f, 0.18f, 0.22f, 0.96f);
			((Graphic)_menuHotkey.Background).color = ((_captureRow == _menuHotkey) ? new Color(0.075f, 0.28f, 0.31f, 0.98f) : new Color(0.12f, 0.18f, 0.22f, 0.96f));
			((Graphic)_compactHotkey.Background).color = ((_captureRow == _compactHotkey) ? new Color(0.075f, 0.28f, 0.31f, 0.98f) : new Color(0.12f, 0.18f, 0.22f, 0.96f));
			((Graphic)_restartSplit.Background).color = new Color(0.18f, 0.13f, 0.08f, 0.96f);
			((Graphic)_forceCheckpoint.Background).color = new Color(0.18f, 0.13f, 0.08f, 0.96f);
			((Graphic)_close.Background).color = new Color(0.1f, 0.19f, 0.22f, 0.96f);
			((Component)_hostHeading).gameObject.SetActive(flag);
			_autoAdvance.Root.SetActive(flag);
			_matchedLoot.Root.SetActive(flag);
			_restartSplit.Root.SetActive(flag);
			_forceCheckpoint.Root.SetActive(flag);
			bool isActive = GameMode.IsActive;
			((Selectable)_restartSplit.Button).interactable = flag && isActive;
			((Selectable)_forceCheckpoint.Button).interactable = flag && isActive && RaceSession.HasPendingCheckpoint();
			if (PhotonNetwork.InRoom && !GameMode.AllPlayersCompatible)
			{
				((Graphic)_status).color = PeakVsUi.DangerColor;
				((TMP_Text)_status).text = "PEAKVS DISABLED  /  EVERY PLAYER NEEDS VERSION 0.7.2";
			}
			else if (isActive && PhotonNetwork.CurrentRoom != null)
			{
				((Graphic)_status).color = PeakVsUi.MutedColor;
				RaceSession.GetLobbyProgress(out var resolved, out var matching, out var total);
				((TMP_Text)_status).text = $"CHECKPOINT {RaceSession.Stage}  /  {resolved} OF {matching} READY  /  {total} CONNECTED";
			}
			else
			{
				((Graphic)_status).color = PeakVsUi.MutedColor;
				((TMP_Text)_status).text = "RACE CONTROLS BECOME AVAILABLE ON THE MOUNTAIN";
			}
			float y = (flag ? (-672f) : (-406f));
			float y2 = (flag ? (-716f) : (-450f));
			float y3 = (flag ? (-775f) : (-509f));
			Place(((TMP_Text)_status).rectTransform, y, 30f);
			SetRowY(_close, y2);
			Place(((TMP_Text)_hint).rectTransform, y3, 24f);
			_panel.sizeDelta = new Vector2(680f, flag ? 814f : 548f);
			((TMP_Text)_hint).text = ((_captureTarget != null) ? "PRESS A KEY  /  ESC CANCEL" : (((object)PeakVsPlugin.MenuToggleKey.Value/*cast due to .constrained prefix*/).ToString().ToUpperInvariant() + " MENU  /  " + ((object)PeakVsPlugin.CompactHudToggleKey.Value/*cast due to .constrained prefix*/).ToString().ToUpperInvariant() + " COMPACT HUD  /  ESC CLOSE"));
			int fontRevision = PeakVsUi.FontRevision;
			if (forceFont || fontRevision != _lastFontRevision)
			{
				_lastFontRevision = fontRevision;
				ApplyFonts();
			}
		}

		private static void SetRowY(MenuRow row, float y)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			row.Root.GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, y);
		}

		private static void SetToggleStyle(MenuRow row, bool enabled)
		{
			//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)
			//IL_0052: 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)
			((Graphic)row.Background).color = (enabled ? new Color(0.075f, 0.28f, 0.31f, 0.98f) : new Color(0.14f, 0.15f, 0.17f, 0.98f));
			((Graphic)row.Value).color = (enabled ? PeakVsUi.AccentColor : PeakVsUi.MutedColor);
		}

		private static void ApplyFonts()
		{
			TextMeshProUGUI[] componentsInChildren = ((Component)_canvas).GetComponentsInChildren<TextMeshProUGUI>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				PeakVsUi.ApplyFont((TMP_Text)(object)componentsInChildren[i]);
			}
		}

		private static void ToggleHud()
		{
			PeakVsPlugin.ShowRaceHud.Value = !PeakVsPlugin.ShowRaceHud.Value;
		}

		private static void CycleHudScale()
		{
			float num = Mathf.Round((PeakVsPlugin.HudScale.Value + 0.1f) * 10f) / 10f;
			PeakVsPlugin.HudScale.Value = ((num > 1.5f) ? 0.7f : num);
		}

		private static void CycleRivalOpacity()
		{
			float num = Mathf.Round((PeakVsPlugin.RemoteScoutOpacity.Value + 0.1f) * 10f) / 10f;
			PeakVsPlugin.RemoteScoutOpacity.Value = ((num > 0.9f) ? 0.2f : num);
		}

		private static void BeginKeyCapture(MenuRow row, ConfigEntry<KeyCode> target)
		{
			_captureRow = row;
			_captureTarget = target;
			_captureStartFrame = Time.frameCount;
		}

		private unsafe static void CaptureHotkey()
		{
			//IL_003e: 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_0044: 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_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_0093: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			if (Time.frameCount <= _captureStartFrame || !Input.anyKeyDown)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)27))
			{
				EndKeyCapture();
				return;
			}
			Array values = Enum.GetValues(typeof(KeyCode));
			for (int i = 0; i < values.Length; i++)
			{
				KeyCode val = (KeyCode)values.GetValue(i);
				if ((int)val != 0 && !((object)(*(KeyCode*)(&val))/*cast due to .constrained prefix*/).ToString().StartsWith("Mouse", StringComparison.Ordinal) && Input.GetKeyDown(val))
				{
					ConfigEntry<KeyCode> val2 = ((_captureTarget == PeakVsPlugin.MenuToggleKey) ? PeakVsPlugin.CompactHudToggleKey : PeakVsPlugin.MenuToggleKey);
					KeyCode value = _captureTarget.Value;
					_captureTarget.Value = val;
					if (val2.Value == val)
					{
						val2.Value = value;
					}
					EndKeyCapture();
					break;
				}
			}
		}

		private static void EndKeyCapture()
		{
			_captureTarget = null;
			_captureRow = null;
			Refresh(forceFont: true);
		}

		private static void ToggleAutoAdvance()
		{
			if (PhotonNetwork.IsMasterClient)
			{
				PeakVsPlugin.AutoLightCheckpoints.Value = !PeakVsPlugin.AutoLightCheckpoints.Value;
			}
		}

		private static void ToggleMatchedLoot()
		{
			if (PhotonNetwork.IsMasterClient)
			{
				RaceSession.HostSetMatchedLuggageLoot(!RaceSession.SameLuggageLoot);
			}
		}

		private static void RestartSplit()
		{
			RaceSession.HostRestartCurrentSplit();
		}

		private static void ForceCheckpoint()
		{
			RaceSession.HostForceCheckpoint();
		}

		private static void Close()
		{
			_captureTarget = null;
			_captureRow = null;
			if ((Object)(object)_window != (Object)null && ((MenuWindow)_window).isOpen)
			{
				CloseMethod.Invoke(_window, null);
			}
		}
	}
	internal static class PrivateNetworkContext
	{
		[ThreadStatic]
		internal static byte Group;

		[ThreadStatic]
		internal static int OwnerActor;

		internal static byte Resolve(object instance)
		{
			return Resolve(instance, 0);
		}

		private static byte Resolve(object instance, int depth)
		{
			if (instance == null || depth > 2)
			{
				return 0;
			}
			Component val = (Component)((instance is Component) ? instance : null);
			if ((Object)(object)val != (Object)null)
			{
				PhotonView componentInParent = val.GetComponentInParent<PhotonView>();
				if ((Object)(object)componentInParent != (Object)null && PrivateLoot.IsPrivateGroup(componentInParent.Group))
				{
					return componentInParent.Group;
				}
				Item componentInParent2 = val.GetComponentInParent<Item>();
				if ((Object)(object)componentInParent2 != (Object)null && PrivateLoot.IsPrivate(componentInParent2))
				{
					return ((MonoBehaviourPun)componentInParent2).photonView.Group;
				}
				return 0;
			}
			FieldInfo[] fields = instance.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			for (int i = 0; i < fields.Length; i++)
			{
				Type fieldType = fields[i].FieldType;
				if (typeof(Component).IsAssignableFrom(fieldType) || fieldType.Name.Contains("<"))
				{
					byte b = Resolve(fields[i].GetValue(instance), depth + 1);
					if (b != 0)
					{
						return b;
					}
				}
			}
			return 0;
		}

		internal static int ResolveOwner(object instance)
		{
			return ResolveOwner(instance, 0);
		}

		private static int ResolveOwner(object instance, int depth)
		{
			if (instance == null || depth > 2)
			{
				return 0;
			}
			Item val = (Item)((instance is Item) ? instance : null);
			if ((Object)(object)val != (Object)null)
			{
				return ResolveItemOwner(val);
			}
			Component val2 = (Component)((instance is Component) ? instance : null);
			if ((Object)(object)val2 != (Object)null)
			{
				Item componentInParent = val2.GetComponentInParent<Item>();
				if ((Object)(object)componentInParent != (Object)null)
				{
					return ResolveItemOwner(componentInParent);
				}
				Character componentInParent2 = val2.GetComponentInParent<Character>();
				if ((Object)(object)componentInParent2 != (Object)null && (Object)(object)((MonoBehaviourPun)componentInParent2).photonView != (Object)null)
				{
					return ((MonoBehaviourPun)componentInParent2).photonView.OwnerActorNr;
				}
				if (!PrivateLoot.TryGetRegisteredOwnedVisualActor(val2.GetComponentInParent<PhotonView>(), out var ownerActor))
				{
					return 0;
				}
				return ownerActor;
			}
			FieldInfo[] fields = instance.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			for (int i = 0; i < fields.Length; i++)
			{
				Type fieldType = fields[i].FieldType;
				if (typeof(Component).IsAssignableFrom(fieldType) || fieldType.Name.Contains("<"))
				{
					int num = ResolveOwner(fields[i].GetValue(instance), depth + 1);
					if (num > 0)
					{
						return num;
					}
				}
			}
			return 0;
		}

		private static int ResolveItemOwner(Item item)
		{
			if ((Object)(object)item == (Object)null || (Object)(object)((MonoBehaviourPun)item).photonView == (Object)null)
			{
				return 0;
			}
			if (PrivateLoot.IsPrivate(item))
			{
				Player localPlayer = PhotonNetwork.LocalPlayer;
				if (localPlayer == null)
				{
					return 0;
				}
				return localPlayer.ActorNumber;
			}
			if (PrivateLoot.TryGetRegisteredOwnedVisualActor(((MonoBehaviourPun)item).photonView, out var ownerActor))
			{
				return ownerActor;
			}
			return 0;
		}
	}
	internal static class NetworkContextPatcher
	{
		private struct ContextState
		{
			internal byte Group;

			internal int OwnerActor;
		}

		private static readonly Dictionary<short, OpCode> OneByteOpCodes;

		private static readonly Dictionary<short, OpCode> TwoByteOpCodes;

		private static readonly MethodInfo EnterMethod;

		private static readonly MethodInfo ExitMethod;

		static NetworkContextPatcher()
		{
			OneByteOpCodes = new Dictionary<short, OpCode>();
			TwoByteOpCodes = new Dictionary<short, OpCode>();
			EnterMethod = AccessTools.Method(typeof(NetworkContextPatcher), "Enter", (Type[])null, (Type[])null);
			ExitMethod = AccessTools.Method(typeof(NetworkContextPatcher), "Exit", (Type[])null, (Type[])null);
			FieldInfo[] fields = typeof(OpCodes).GetFields(BindingFlags.Static | BindingFlags.Public);
			for (int i = 0; i < fields.Length; i++)
			{
				OpCode value = (OpCode)fields[i].GetValue(null);
				if (value.Size == 1)
				{
					OneByteOpCodes[value.Value] = value;
				}
				else
				{
					TwoByteOpCodes[(short)(value.Value & 0xFF)] = value;
				}
			}
		}

		internal static void Install(Harmony harmony)
		{
			//IL_0083: 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_009a: Expected O, but got Unknown
			//IL_009a: Expected O, but got Unknown
			int num = 0;
			Type[] array;
			try
			{
				array = typeof(Item).Assembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				array = Array.FindAll(ex.Types, (Type type) => type != null);
			}
			for (int num2 = 0; num2 < array.Length; num2++)
			{
				MethodInfo[] methods;
				try
				{
					methods = array[num2].GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
				catch
				{
					continue;
				}
				foreach (MethodInfo methodInfo in methods)
				{
					if (!methodInfo.IsAbstract && CallsPhotonInstantiate(methodInfo))
					{
						try
						{
							harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(EnterMethod), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(ExitMethod), (HarmonyMethod)null);
							num++;
						}
						catch (Exception ex2)
						{
							PeakVsPlugin.Log.LogWarning((object)$"Could not add item network context to {methodInfo}: {ex2.Message}");
						}
					}
				}
			}
			PeakVsPlugin.Log.LogInfo((object)$"Installed private item context on {num} PEAK network-spawn call sites.");
		}

		private static void Enter(MethodBase __originalMethod, object __instance, out ContextState __state)
		{
			__state = new ContextState
			{
				Group = PrivateNetworkContext.Group,
				OwnerActor = PrivateNetworkContext.OwnerActor
			};
			int num = PrivateNetworkContext.ResolveOwner(__instance);
			if (num > 0)
			{
				PrivateNetworkContext.OwnerActor = num;
			}
			if (ShouldBePublicVisual(__originalMethod, __instance))
			{
				PrivateNetworkContext.Group = 0;
				return;
			}
			byte b = PrivateNetworkContext.Resolve(__instance);
			if (b != 0)
			{
				PrivateNetworkContext.Group = b;
			}
		}

		private static Exception Exit(Exception __exception, ContextState __state)
		{
			PrivateNetworkContext.Group = __state.Group;
			PrivateNetworkContext.OwnerActor = __state.OwnerActor;
			return __exception;
		}

		private static bool ShouldBePublicVisual(MethodBase method, object instance)
		{
			if (instance is BackpackVisuals)
			{
				return true;
			}
			if (method.DeclaringType == typeof(CharacterCarrying) && method.Name == "RPCA_StartCarry")
			{
				return true;
			}
			if (method.DeclaringType != typeof(CharacterItems))
			{
				return false;
			}
			if (!(method.Name == "EquipSlot") && !(method.Name == "DropItemRpc") && !(method.Name == "DropItemFromSlotRPC") && !(method.Name == "HammerClimbingSpike"))
			{
				return method.Name == "RPC_SpawnItemInHandMaster";
			}
			return true;
		}

		private static bool CallsPhotonInstantiate(MethodInfo method)
		{
			MethodBody methodBody;
			try
			{
				methodBody = method.GetMethodBody();
			}
			catch
			{
				return false;
			}
			if (methodBody == null)
			{
				return false;
			}
			byte[] iLAsByteArray = methodBody.GetILAsByteArray();
			int operandSize;
			for (int i = 0; i < iLAsByteArray.Length; i += operandSize)
			{
				byte b = iLAsByteArray[i++];
				OpCode value;
				if (b == 254)
				{
					if (i >= iLAsByteArray.Length || !TwoByteOpCodes.TryGetValue(iLAsByteArray[i++], out value))
					{
						return false;
					}
				}
				else if (!OneByteOpCodes.TryGetValue(b, out value))
				{
					return false;
				}
				operandSize = GetOperandSize(value.OperandType, iLAsByteArray, i);
				if ((!(value == OpCodes.Call) && !(value == OpCodes.Callvirt)) || operandSize != 4)
				{
					continue;
				}
				int metadataToken = BitConverter.ToInt32(iLAsByteArray, i);
				try
				{
					MethodBase methodBase = method.Module.ResolveMethod(metadataToken, method.DeclaringType?.GetGenericArguments(), method.GetGenericArguments());
					if (methodBase?.DeclaringType == typeof(PhotonNetwork) && methodBase.Name.StartsWith("Instantiate", StringComparison.Ordinal))
					{
						return true;
					}
				}
				catch
				{
				}
			}
			return false;
		}

		private static int GetOperandSize(OperandType type, byte[] il, int position)
		{
			switch (type)
			{
			case OperandType.InlineNone:
				return 0;
			case OperandType.ShortInlineBrTarget:
			case OperandType.ShortInlineI:
			case OperandType.ShortInlineVar:
				return 1;
			case OperandType.InlineVar:
				return 2;
			case OperandType.InlineI8:
			case OperandType.InlineR:
				return 8;
			case OperandType.InlineSwitch:
			{
				int num = BitConverter.ToInt32(il, position);
				return 4 + num * 4;
			}
			default:
				return 4;
			}
		}
	}
	[HarmonyPatch]
	internal static class PhotonInstantiateGroupPatch
	{
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(PhotonNetwork), "Instantiate", new Type[5]
			{
				typeof(string),
				typeof(Vector3),
				typeof(Quaternion),
				typeof(byte),
				typeof(object[])
			}, (Type[])null);
		}

		private static void Prefix(ref byte group)
		{
			if (GameMode.IsActive && PrivateNetworkContext.Group != 0)
			{
				group = PrivateNetworkContext.Group;
			}
		}

		private static void Postfix(GameObject __result)
		{
			PrivateLoot.RegisterOwnedVisual(__result, PrivateNetworkContext.OwnerActor);
		}
	}
	[HarmonyPatch]
	internal static class PhotonRoomInstantiatePatch
	{
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(PhotonNetwork), "InstantiateRoomObject", new Type[5]
			{
				typeof(string),
				typeof(Vector3),
				typeof(Quaternion),
				typeof(byte),
				typeof(object[])
			}, (Type[])null);
		}

		private static bool Prefix(string prefabName, Vector3 position, Quaternion rotation, byte group, object[] data, ref GameObject __result)
		{
			//IL_0017: 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)
			if (!GameMode.IsActive)
			{
				return true;
			}
			byte b = PrivateNetworkContext.Group;
			if (b == 0)
			{
				return true;
			}
			__result = PhotonNetwork.Instantiate(prefabName, position, rotation, b, data);
			return false;
		}

		private static void Postfix(GameObject __result)
		{
			PrivateLoot.RegisterOwnedVisual(__result, PrivateNetworkContext.OwnerActor);
		}
	}
	[HarmonyPatch]
	internal static class PhotonItemRoomInstantiatePatch
	{
		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(PhotonNetwork), "InstantiateItemRoom", new Type[3]
			{
				typeof(string),
				typeof(Vector3),
				typeof(Quaternion)
			}, (Type[])null);
		}

		private static bool Prefix(string prefabName, Vector3 position, Quaternion rotation, ref GameObject __result)
		{
			//IL_0020: 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)
			if (!GameMode.IsActive)
			{
				return true;
			}
			byte b = PrivateNetworkContext.Group;
			if (b == 0)
			{
				return true;
			}
			__result = PhotonNetwork.Instantiate("0_Items/" + prefabName, position, rotation, b, (object[])null);
			return false;
		}

		private static void Postfix(GameObject __result)
		{
			PrivateLoot.RegisterOwnedVisual(__result, PrivateNetworkContext.OwnerActor);
		}
	}
	[HarmonyPatch(typeof(PhotonNetwork), "get_IsMasterClient")]
	internal static class PrivateItemAuthorityPatch
	{
		private static void Postfix(ref bool __result)
		{
			if (GameMode.IsActive && PrivateNetworkContext.Group != 0)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch(typeof(Luggage), "Interact_CastFinished")]
	internal static class LuggageInteractPatch
	{
		private static bool Prefix(Luggage __instance, Character interactor)
		{
			if (!GameMode.IsActive)
			{
				return true;
			}
			PrivateLoot.OpenLuggage(__instance, interactor);
			return false;
		}
	}
	[HarmonyPatch(typeof(Luggage), "OpenLuggageRPC")]
	internal static class LuggageRpcPatch
	{
		private static bool Prefix()
		{
			return !GameMode.IsActive;
		}
	}
	[HarmonyPatch(typeof(Luggage), "OnCharacterRegistered")]
	internal static class LuggageJoinSyncPatch
	{
		private static bool Prefix()
		{
			return !GameMode.IsActive;
		}
	}
	[HarmonyPatch(typeof(Luggage), "OpenImmediatelyNoNotify")]
	internal static class LuggageImmediateOpenPatch
	{
		private static bool Prefix()
		{
			return !GameMode.IsActive;
		}
	}
	[HarmonyPatch(typeof(RespawnChest), "SpawnItems")]
	internal static class RespawnChestSpawnPatch
	{
		private static bool Prefix(ref List<PhotonView> __result)
		{
			if (!GameMode.IsActive)
			{
				return true;
			}
			__result = new List<PhotonView>();
			return false;
		}
	}
	[HarmonyPatch(typeof(LootData), "IsValidToSpawn")]
	internal static class MultiplayerLootFilterPatch
	{
		private static void Postfix(LootData __instance, ref bool __result)
		{
			if (GameMode.IsActive & __result)
			{
				__result = !PrivateLoot.IsForbidden(((Component)__instance).GetComponent<Item>());
			}
		}
	}
	[HarmonyPatch(typeof(Item), "Awake")]
	internal static class SharedItemClonePatch
	{
		private static void Postfix(Item __instance)
		{
			PrivateLoot.QueueSharedItemClone(__instance);
		}
	}
	[HarmonyPatch(typeof(Item), "Start")]
	internal static class OwnedItemPresentationPatch
	{
		private static void Postfix(Item __instance)
		{
			RaceSession.ApplyItemIsolation(__instance);
		}
	}
	[HarmonyPatch]
	internal static class OwnedItemPresentationRefreshPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Method(typeof(Item), "SetState", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(Item), "SetItemInstanceDataRPC", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(Item), "HoverEnter", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(Item), "HoverExit", (Type[])null, (Type[])null);
		}

		private static void Postfix(Item __instance)
		{
			RaceSession.ReapplyOwnedItemPresentation(__instance);
		}
	}
	[HarmonyPatch]
	internal static class PrivateItemPickupPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type[] types;
			try
			{
				types = typeof(Item).Assembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				types = Array.FindAll(ex.Types, (Type type2) => type2 != null);
			}
			foreach (Type type in types)
			{
				if (!(type == null) && !type.IsAbstract && typeof(Item).IsAssignableFrom(type))
				{
					MethodInfo method = type.GetMethod("Interact", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(Character) }, null);
					if (method != null)
					{
						yield return method;
					}
				}
			}
		}

		private static bool Prefix(MethodBase __originalMethod, Item __instance, Character interactor)
		{
			if (!GameMode.IsActive)
			{
				return true;
			}
			if (PrivateLoot.IsRivalOwned(__instance))
			{
				return false;
			}
			if (__originalMethod.DeclaringType != typeof(Item))
			{
				return true;
			}
			return !PrivateLoot.RequestPickup(__instance, interactor);
		}
	}
	[HarmonyPatch]
	internal static class RivalItemInteractiblePatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type[] types;
			try
			{
				types = typeof(Item).Assembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				types = Array.FindAll(ex.Types, (Type type2) => type2 != null);
			}
			foreach (Type type in types)
			{
				if (!(type == null) && !type.IsAbstract && typeof(Item).IsAssignableFrom(type))
				{
					MethodInfo method = type.GetMethod("IsInteractible", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(Character) }, null);
					if (method != null)
					{
						yield return method;
					}
				}
			}
		}

		private static void Postfix(Item __instance, ref bool __result)
		{
			if (__result && PrivateLoot.IsRivalOwned(__instance))
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch]
	internal static class RivalOwnedInteractibleAvailabilityPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type[] types;
			try
			{
				types = typeof(Item).Assembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				types = Array.FindAll(ex.Types, (Type type2) => type2 != null);
			}
			string[] names = new string[2] { "IsInteractible", "IsConstantlyInteractable" };
			foreach (Type type in types)
			{
				if (type == null || type.IsAbstract || !typeof(IInteractible).IsAssignableFrom(type))
				{
					continue;
				}
				for (int nameIndex = 0; nameIndex < names.Length; nameIndex++)
				{
					MethodInfo method = type.GetMethod(names[nameIndex], BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(Character) }, null);
					if (method != null && method.ReturnType == typeof(bool))
					{
						yield return method;
					}
				}
			}
		}

		private static bool Prefix(object __instance, Character interactor, ref bool __result)
		{
			if (PrivateLoot.CanUseOwnedVisual((Component)((__instance is Component) ? __instance : null), interactor))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch]
	internal static class RivalOwnedInteractibleUsePatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type[] types;
			try
			{
				types = typeof(Item).Assembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				types = Array.FindAll(ex.Types, (Type type2) => type2 != null);
			}
			string[] names = new string[2] { "Interact", "Interact_CastFinished" };
			foreach (Type type in types)
			{
				if (type == null || type.IsAbstract || !typeof(IInteractible).IsAssignableFrom(type))
				{
					continue;
				}
				for (int nameIndex = 0; nameIndex < names.Length; nameIndex++)
				{
					MethodInfo method = type.GetMethod(names[nameIndex], BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(Character) }, null);
					if (method != null && method.ReturnType == typeof(void))
					{
						yield return method;
					}
				}
			}
		}

		private static bool Prefix(object __instance, Character interactor)
		{
			return PrivateLoot.CanUseOwnedVisual((Component)((__instance is Component) ? __instance : null), interactor);
		}
	}
	[HarmonyPatch(typeof(ClimbHandle), "RPCA_Hang")]
	internal static class RivalPitonHangPatch
	{
		private static bool Prefix(ClimbHandle __instance, PhotonView view)
		{
			Character interactor = (((Object)(object)view != (Object)null) ? ((Component)view).GetComponent<Character>() : null);
			return PrivateLoot.CanUseOwnedVisual((Component)(object)__instance, interactor);
		}
	}
	[HarmonyPatch(typeof(Constructable), "CreatePrefabRPC")]
	internal static class OwnedConstructedPrefabPatch
	{
		private static bool Prefix(Constructable __instance, Vector3 position, Quaternion rotation)
		{
			//IL_0026: 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)
			if (!GameMode.IsActive || (Object)(object)__instance == (Object)null || (Object)(object)__instance.constructedPrefab == (Object)null)
			{
				return true;
			}
			GameObject val = Object.Instantiate<GameObject>(__instance.constructedPrefab, position, rotation);
			PhotonView component = ((Component)__instance).GetComponent<PhotonView>();
			if ((Object)(object)val != (Object)null && PrivateLoot.TryGetRegisteredOwnedVisualActor(component, out var ownerActor))
			{
				PeakVsOwnedObject peakVsOwnedObject = val.AddComponent<PeakVsOwnedObject>();
				peakVsOwnedObject.OwnerActor = ownerActor;
				RaceSession.ApplyOwnedObject((Component)(object)peakVsOwnedObject, ownerActor);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(BackpackOnBackVisuals), "IsInteractible")]
	internal static class RivalWornBackpackInteractiblePatch
	{
		private static bool Prefix(BackpackOnBackVisuals __instance, Character interactor, ref bool __result)
		{
			if (PrivateLoot.CanAccessBackpack(__instance.character, interactor))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(BackpackOnBackVisuals), "IsConstantlyInteractable")]
	internal static class RivalWornBackpackHoldPatch
	{
		private static bool Prefix(BackpackOnBackVisuals __instance, Character interactor, ref bool __result)
		{
			if (PrivateLoot.CanAccessBackpack(__instance.character, interactor))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(BackpackOnBackVisuals), "Interact_CastFinished")]
	internal static class RivalWornBackpackOpenPatch
	{
		private static bool Prefix(BackpackOnBackVisuals __instance, Character interactor)
		{
			return PrivateLoot.CanAccessBackpack(__instance.character, interactor);
		}
	}
	[HarmonyPatch(typeof(BackpackWheel), "Choose")]
	internal static class RivalBackpackWheelGuardPatch
	{
		private static bool Prefix(BackpackWheel __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return PrivateLoot.CanAccessBackpack(__instance.backpack, Character.localCharacter);
		}
	}
	[HarmonyPatch(typeof(BackpackWheel), "InitWheel")]
	internal static class RivalBackpackWheelOpenGuardPatch
	{
		private static bool Prefix(BackpackReference bp)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return PrivateLoot.CanAccessBackpack(bp, Character.localCharacter);
		}
	}
	[HarmonyPatch(typeof(GUIManager), "OpenBackpackWheel")]
	internal static class RivalBackpackGuiOpenGuardPatch
	{
		private static bool Prefix(BackpackReference backpackReference)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return PrivateLoot.CanAccessBackpack(backpackReference, Character.localCharacter);
		}
	}
	[HarmonyPatch(typeof(CharacterBackpackHandler), "StashInBackpack")]
	internal static class RivalBackpackStashGuardPatch
	{
		private static bool Prefix(CharacterBackpackHandler __instance, Character interactor)
		{
			return PrivateLoot.CanAccessBackpack(((Component)__instance).GetComponent<Character>(), interactor);
		}
	}
	[HarmonyPatch(typeof(CharacterBackpackHandler), "AddFuelToJetpack")]
	internal static class RivalBackpackFuelGuardPatch
	{
		private static bool Prefix(CharacterBackpackHandler __instance, Character interactor)
		{
			return PrivateLoot.CanAccessBackpack(((Component)__instance).GetComponent<Character>(), interactor);
		}
	}
	[HarmonyPatch(typeof(CharacterBackpackHandler), "RPCAddItemToCharacterBackpack")]
	internal static class EquippedBackpackAuthoritySyncPatch
	{
		private static bool Prefix(CharacterBackpackHandler __instance, PhotonView playerView)
		{
			if (!GameMode.IsActive)
			{
				return true;
			}
			Character component = ((Component)__instance).GetComponent<Character>();
			object obj;
			if (!((Object)(object)playerView != (Object)null))
			{
				obj = null;
			}
			else
			{
				Player component2 = ((Component)playerView).GetComponent<Player>();
				obj = ((component2 != null) ? component2.character : null);
			}
			Character interactor = (Character)obj;
			return PrivateLoot.CanAccessBackpack(component, interactor);
		}

		private static void Postfix(CharacterBackpackHandler __instance, PhotonView playerView)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if (!GameMode.IsActive || !PhotonNetwork.IsMasterClient || (Object)(object)playerView == (Object)null)
			{
				return;
			}
			Character component = ((Component)__instance).GetComponent<Character>();
			Player component2 = ((Component)playerView).GetComponent<Player>();
			Character interactor = ((component2 != null) ? component2.character : null);
			if (PrivateLoot.CanAccessBackpack(component, interactor))
			{
				Player val = (((Object)(object)component != (Object)null) ? component.player : null);
				if (!((Object)(object)val == (Object)null))
				{
					InventorySyncData val2 = default(InventorySyncData);
					((InventorySyncData)(ref val2))..ctor(val.itemSlots, val.backpackSlot, val.tempFullSlot);
					((MonoBehaviourPun)val).photonView.RPC("SyncInventoryRPC", (RpcTarget)1, new object[2]
					{
						IBinarySerializable.ToManagedArray<InventorySyncData>(val2),
						true
					});
				}
			}
		}
	}
	[HarmonyPatch(typeof(Backpack), "RPCAddItemToBackpack")]
	internal static class BackpackItemAuthoritySyncPatch
	{
		private static void Postfix(Backpack __instance)
		{
			if (GameMode.IsActive && PhotonNetwork.IsMasterClient && (Object)(object)__instance != (Object)null && (Object)(object)((MonoBehaviourPun)__instance).photonView != (Object)null && ((Item)__instance).data != null)
			{
				((MonoBehaviourPun)__instance).photonView.RPC("SetItemInstanceDataRPC", (RpcTarget)1, new object[1] { ((Item)__instance).data });
			}
		}
	}
	[HarmonyPatch(typeof(BackpackVisuals), "RemoveVisuals")]
	internal static class BackpackVisualCleanupPatch
	{
		private static void Prefix(BackpackVisuals __instance)
		{
			if (!GameMode.IsActive || PhotonNetwork.IsMasterClient)
			{
				return;
			}
			foreach (Item value in __instance.spawnedVisualItems.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					((Component)value).gameObject.SetActive(false);
				}
			}
		}

		private static void Postfix(BackpackVisuals __instance)
		{
			if (GameMode.IsActive)
			{
				__instance.spawnedVisualItems.Clear();
			}
		}
	}
	[HarmonyPatch(typeof(ScoutmasterSpawner), "SpawnScoutmaster")]
	internal static class ScoutmasterSpawnerPatch
	{
		private static bool Prefix()
		{
			return !GameMode.IsActive;
		}
	}
	[HarmonyPatch(typeof(Scoutmaster), "SetCurrentTarget")]
	internal static class ScoutmasterTargetPatch
	{
		private static bool Prefix()
		{
			return !GameMode.IsActive;
		}
	}
	[HarmonyPatch(typeof(RunSettings), "GetValue", new Type[]
	{
		typeof(SETTINGTYPE),
		typeof(bool)
	})]
	internal static class ScoutmasterSettingPatch
	{
		private static void Postfix(SETTINGTYPE setting, ref int __result)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			if (GameMode.IsActive && (int)setting == 2700)
			{
				__result = 0;
			}
		}
	}
	[HarmonyPatch(typeof(Character), "CheckEndGame")]
	internal static class RaceDeathGameOverPatch
	{
		private static bool Prefix()
		{
			return !GameMode.IsActive;
		}
	}
	[HarmonyPatch(typeof(Character), "RPCA_Die")]
	internal static class RaceForfeitPatch
	{
		private static void Postfix(Character __instance)
		{
			if (GameMode.IsActive && __instance.IsLocal)
			{
				RaceSession.ReportForfeit();
			}
		}
	}
	[HarmonyPatch(typeof(Campfire), "Light_Rpc")]
	internal static class RaceCheckpointPatch
	{
		private static void Postfix(Campfire __instance, bool updateSegment)
		{
			RaceSession.OnCampfireLit(__instance, updateSegment);
		}
	}
	[HarmonyPatch]
	internal static class RacerInteractionPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Method(typeof(CharacterInteractible), "IsInteractible", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(CharacterInteractible), "IsPrimaryInteractible", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(CharacterInteractible), "IsSecondaryInteractible", (Type[])null, (Type[])null);
		}

		private static bool Prefix(CharacterInteractible __instance, Character interactor, ref bool __result)
		{
			if (!GameMode.IsActive)
			{
				return true;
			}
			Character val = __instance.character ?? ((Component)__instance).GetComponent<Character>();
			if ((Object)(object)interactor != (Object)null && interactor.IsLocal && (Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)interactor && !val.isBot)
			{
				__result = false;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CharacterGrabbing), "TargetCanBeHelped", new Type[]
	{
		typeof(Character),
		typeof(Character)
	})]
	internal static class RacerHelpingPatch
	{
		private static bool Prefix(Character target, Character helper, ref bool __result)
		{
			if (GameMode.IsActive && (Object)(object)target != (Object)null && (Object)(object)helper != (Object)null && (Object)(object)target != (Object)(object)helper && !target.isBot && !helper.isBot)
			{
				__result = false;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Character), "AddForceAtPosition")]
	internal static class RacerForceIsolationPatch
	{
		private static bool Prefix(Character __instance)
		{
			if (GameMode.IsActive && !__instance.IsLocal)
			{
				return __instance.isBot;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Character), "Fall")]
	internal static class RacerFallIsolationPatch
	{
		private static bool Prefix(Character __instance)
		{
			if (GameMode.IsActive && !__instance.IsLocal)
			{
				return __instance.isBot;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CharacterCarrying), "StartCarry")]
	internal static class RacerCarryIsolationPatch
	{
		private static bool Prefix(Character target)
		{
			if (GameMode.IsActive && !((Object)(object)target == (Object)null))
			{
				return target.isBot;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ScoutCannon), "FixedUpdate")]
	internal static class OwnedScoutCannonFieldPatch
	{
		private static bool Prefix(ScoutCannon __instance, PhotonView ___view, Transform ___tube, Transform ___entry, Character ___target)
		{
			//IL_009a: 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_0224: 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_0236: 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_024d: 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_0258: 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_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: 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_0104: 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_0109: Invalid comparison between Unknown and I4
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Invalid comparison between Unknown and I4
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Invalid comparison between Unknown and I4
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Invalid comparison between Unknown and I4
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Invalid comparison between Unknown and I4
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Invalid comparison between Unknown and I4
			//IL_013f: 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_014a: 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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: 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_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: 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_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: 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_01d7: 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_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			if (!GameMode.IsActive)
			{
				return true;
			}
			if (!PhotonNetwork.IsMasterClient || (Object)(object)___view == (Object)null || (Object)(object)___tube == (Object)null || (Object)(object)___entry == (Object)null || !PrivateLoot.TryGetRegisteredOwnedVisualActor(___view, out var ownerActor))
			{
				return false;
			}
			Character val = null;
			List<Character> allPlayerCharacters = PlayerHandler.GetAllPlayerCharacters();
			for (int i = 0; i < allPlayerCharacters.Count; i++)
			{
				Character val2 = allPlayerCharacters[i];
				if ((Object)(object)val2 != (Object)null && (Object)(object)((MonoBehaviourPun)val2).photonView != (Object)null && ((MonoBehaviourPun)val2).photonView.OwnerActorNr == ownerActor)
				{
					val = val2;
					break;
				}
			}
			Character val3 = null;
			if ((Object)(object)val != (Object)null && Vector3.Distance(val.Center, ___entry.position) < 1f)
			{
				val3 = val;
				RaycastHit val7;
				if ((Object)(object)val == (Object)(object)___target)
				{
					if (val.data.sinceJump >= 0.5f)
					{
						List<Bodypart> partList = val.refs.ragdoll.partList;
						for (int j = 0; j < partList.Count; j++)
						{
							Bodypart val4 = partList[j];
							BodypartType partType = val4.partType;
							if ((int)partType == 7 || (int)partType == 10 || (int)partType == 6 || (int)partType == 9 || (int)partType == 5 || (int)partType == 8)
							{
								continue;
							}
							Vector3 val5 = Vector3.Project(val4.transform.position - ___tube.position, ___tube.forward);
							Vector3 val6 = Vector3.ClampMagnitude(___tube.position + val5 - val4.transform.position, 1f);
							val4.Rig.AddForce(val6 * __instance.pullForce, (ForceMode)5);
							if (___entry.InverseTransformPoint(val4.transform.position).z < 0f)
							{
								val7 = HelperFunctions.LineCheck(___entry.position, val4.transform.position, (LayerType)3, 0f, (QueryTriggerInteraction)1);
								if (Object.op_Implicit((Object)(object)((RaycastHit)(ref val7)).transform))
								{
									val4.Rig.AddForce(___entry.forward * __instance.pullForce, (ForceMode)5);
								}
							}
						}
					}
				}
				else
				{
					val7 = HelperFunctions.LineCheck(___tube.position, val.Center, (LayerType)3, 0f, (QueryTriggerInteraction)1);
					if ((Object)(object)((RaycastHit)(ref val7)).transform == (Object)null)
					{
						Vector3 val8 = ___tube.position - val.Center;
						Vector3 val9 = -((Vector3)(ref val8)).normalized * __instance.pushForce;
						List<Bodypart> partList2 = val.refs.ragdoll.partList;
						for (int k = 0; k < partList2.Count; k++)
						{
							partList2[k].Rig.AddForce(val9, (ForceMode)5);
						}
					}
				}
			}
			if ((Object)(object)___target != (Object)(object)val3)
			{
				___view.RPC("RPCA_SetTarget", (RpcTarget)0, new object[1] { ((Object)(object)val3 != (Object)null) ? val3.refs.view.ViewID : (-1) });
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(ScoutCannon), "RPCA_LaunchTarget")]
	internal static class OwnedScoutCannonLaunchPatch
	{
		private static bool Prefix(ScoutCannon __instance, int targetID)
		{
			if (!GameMode.IsActive)
			{
				return true;
			}
			PhotonView component = ((Component)__instance).GetComponent<PhotonView>();
			PhotonView photonView = PhotonNetwork.GetPhotonView(targetID);
			if ((Object)(object)component != (Object)null && (Object)(object)photonView != (Object)null && PrivateLoot.TryGetRegisteredOwnedVisualActor(component, out var ownerActor))
			{
				return photonView.OwnerActorNr == ownerActor;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(ScoutCannon), "RPCA_LaunchItem")]
	internal static class OwnedScoutCannonItemLaunchPatch
	{
		private static bool Prefix(ScoutCannon __instance, int targetID)
		{
			if (!GameMode.IsActive)
			{
				return true;
			}
			PhotonView component = ((Component)__instance).GetComponent<PhotonView>();
			PhotonView photonView = PhotonNetwork.GetPhotonView(targetID);
			Item val = (((Object)(object)photonView != (Object)null) ? ((Component)photonView).GetComponent<Item>() : null);
			if ((Object)(object)component == (Object)null || (Object)(object)val == (Object)null || !PrivateLoot.TryGetRegisteredOwnedVisualActor(component, out var ownerActor))
			{
				return false;
			}
			if (PrivateLoot.TryGetRegisteredOwnedVisualActor(photonView, out var ownerActor2))
			{
				return ownerActor2 == ownerActor;
			}
			Player localPlayer = PhotonNetwork.LocalPlayer;
			int num = ((localPlayer != null) ? localPlayer.ActorNumber : 0);
			if (ownerActor == num)
			{
				return PrivateLoot.IsOwnedByLocal(val);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(UIPlayerNames), "CanCannibalize")]
	internal static class RivalChickenTargetPatch
	{
		private static bool Prefix(ref bool __result)
		{
			if (!GameMode.IsActive)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(CharacterCustomization), "BecomeChicken")]
	internal static class RivalChickenVisualPatch
	{
		private static bool Prefix()
		{
			return !GameMode.IsActive;
		}
	}
	[HarmonyPatch(typeof(RopeSegment), "Interact")]
	internal static class PrivateRopeGrabPatch
	{
		private static bool Prefix(RopeSegment __instance, Character interactor)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			Rope rope = __instance.rope;
			if (!GameMode.IsActive || (Object)(object)rope == (Object)null || (Object)(object)((MonoBehaviourPun)rope).photonView == (Object)null)
			{
				return true;
			}
			Player localPlayer = PhotonNetwork.LocalPlayer;
			int num = ((localPlayer != null) ? localPlayer.ActorNumber : 0);
			if (!PrivateLoot.IsPrivateGroup(((MonoBehaviourPun)rope).photonView.Group))
			{
				if (!PrivateLoot.TryGetRegisteredOwnedVisualActor(((MonoBehaviourPun)rope).photonView, out var ownerActor))
				{
					return true;
				}
				int num2 = (((Object)(object)interactor != (Object)null && (Object)(object)((MonoBehaviourPun)interactor).photonView != (Object)null) ? ((MonoBehaviourPun)interactor).photonView.OwnerActorNr : num);
				if (num2 > 0)
				{
					return ownerActor == num2;
				}
				return true;
			}
			if ((Object)(object)interactor != (Object)null && interactor.IsLocal && interactor.refs.ropeHandling.canInteractWithRope)
			{
				interactor.refs.items.EquipSlot(Optionable<byte>.None);
				int num3 = ((Component)__instance).transform.GetSiblingIndex() - 2;
				interactor.refs.ropeHandling.GrabRopeRpc(((MonoBehaviourPun)rope).photonView, num3);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(RopeSegment), "IsInteractible")]
	internal static class RivalRopePromptPatch
	{
		private static bool Prefix(RopeSegment __instance, ref bool __result)
		{
			Rope rope = __instance.rope;
			if (!GameMode.IsActive || (Object)(object)rope == (Object)null || (Object)(object)((MonoBehaviourPun)rope).photonView == (Object)null)
			{
				return true;
			}
			if (!PrivateLoot.TryGetRegisteredOwnedVisualActor(((MonoBehaviourPun)rope).photonView, out var ownerActor))
			{
				return true;
			}
			Player localPlayer = PhotonNetwork.LocalPlayer;
			int num = ((localPlayer != null) ? localPlayer.ActorNumber : 0);
			if (ownerActor <= 0 || ownerActor == num)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(CharacterRopeHandling), "GrabRopeRpc")]
	internal static class MissingPrivateRopeGuardPatch
	{
		private static bool Prefix(PhotonView ropeView)
		{
			if (GameMode.IsActive)
			{
				return (Object)(object)ropeView != (Object)null;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Item), "CanUseSecondary")]
	internal static class FriendItemUsePatch
	{
		private static void Postfix(Item __instance, ref bool __result)
		{
			if (GameMode.IsActive && __instance.canUseOnFriend && __instance.mustUseOnFriend)
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(Action_ApplyMassAffliction), "RunAction")]
	internal static class MassItemIsolationPatch
	{
		private static bool Prefix(Action_ApplyMassAffliction __instance)
		{
			Item component = ((Component)__instance).GetComponent<Item>();
			if (!GameMode.IsActive)
			{
				return true;
			}
			if (!PrivateLoot.IsOwnedByLocal(component))
			{
				return false;
			}
			__instance.TryAddAfflictionToLocalCharacter(true);
			return false;
		}
	}
	[HarmonyPatch(typeof(RespawnRandomScout), "Start")]
	internal static class MultiplayerReviveItemPatch
	{
		private static bool Prefix()
		{
			return !GameMode.IsActive;
		}
	}
	[HarmonyPatch(typeof(RescueHook), "RPCA_RescueCharacter")]
	internal static class RivalRescueClawPatch
	{
		private static bool Prefix(RescueHook __instance, PhotonView characterView)
		{
			if (!GameMode.IsActive || (Object)(object)characterView == (Object)null)
			{
				return true;
			}
			int logicalOwnerActor = PrivateLoot.GetLogicalOwnerActor(((Component)__instance).GetComponent<Item>());
			if (logicalOwnerActor > 0)
			{
				return characterView.OwnerActorNr == logicalOwnerActor;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(GloomSafeZone), "set_isLit")]
	internal static class RivalLanternSafeZonePatch
	{
		private static void Prefix(GloomSafeZone __instance, ref bool value)
		{
			if (value && GameMode.IsActive && PrivateLoot.IsRivalOwned(((Component)__instance).GetComponentInParent<Item>()))
			{
				value = false;
			}
		}
	}
	[HarmonyPatch(typeof(Mandrake), "Update")]
	internal static class RivalMandrakeEffectPatch
	{
		private static void Postfix(Mandrake __instance)
		{
			if (GameMode.IsActive && PrivateLoot.IsRivalOwned(__instance.item) && (Object)(object)__instance.timeEvent != (Object)null)
			{
				((Behaviour)__instance.timeEvent).enabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(RitualDaggerFeedBehavior), "RPC_RitualDaggerBuff")]
	internal static class RivalRitualDaggerBuffPatch
	{
		private static bool Prefix(RitualDaggerFeedBehavior __instance)
		{
			if (!GameMode.IsActive)
			{
				return true;
			}
			int logicalOwnerActor = PrivateLoot.GetLogicalOwnerActor(((Component)__instance).GetComponent<Item>());
			Player localPlayer = PhotonNetwork.LocalPlayer;
			int num = ((localPlayer != null) ? localPlayer.ActorNumber : 0);
			if (logicalOwnerActor > 0)
			{
				return logicalOwnerActor == num;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ScoutEffigy), "FinishConstruction")]
	internal static class RaceScoutEffigyUsePatch
	{
		private static bool Prefix(ref GameObject __result)
		{
			if (!GameMode.IsActive)
			{
				return true;
			}
			__result = null;
			return false;
		}
	}
	[HarmonyPatch(typeof(Dynamite), "TestLightWick")]
	internal static class RivalDynamiteIgnitionPatch
	{
		private static bool Prefix(Dynamite __instance)
		{
			//IL_005b: 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 (!GameMode.IsActive || !PhotonNetwork.IsMasterClient)
			{
				return !GameMode.IsActive;
			}
			int logicalOwnerActor = PrivateLoot.GetLogicalOwnerActor(((Component)__instance).GetComponent<Item>());
			List<Character> allPlayerCharacters = PlayerHandler.GetAllPlayerCharacters();
			for (int i = 0; i < allPlayerCharacters.Count; i++)
			{
				Character val = allPlayerCharacters[i];
				if ((Object)(object)val != (Object)null && (Object)(object)((MonoBehaviourPun)val).photonView != (Object)null && ((MonoBehaviourPun)val).photonView.OwnerActorNr == logicalOwnerActor && Vector3.Distance(val.Center, ((Component)__instance).transform.position) < __instance.lightFuseRadius)
				{
					__instance.LightFlare();
					break;
				}
			}
			return false;
		}
	}
	internal sealed class PeakVsOwnedEffect : MonoBehaviour
	{
		internal int OwnerActor;
	}
	[HarmonyPatch(typeof(Dynamite), "RPC_Explode")]
	internal static class DynamiteEffectOwnershipPatch
	{
		private static void Prefix(out HashSet<int> __state)
		{
			if (!GameMode.IsActive)
			{
				__state = null;
				return;
			}
			__state = new HashSet<int>();
			AOE[] array = Object.FindObjectsByType<AOE>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				__state.Add(((Object)array[i]).GetInstanceID());
			}
		}

		private static void Postfix(Dynamite __instance, HashSet<int> __state)
		{
			if (!GameMode.IsActive)
			{
				return;
			}
			int logicalOwnerActor = PrivateLoot.GetLogicalOwnerActor(((Component)__instance).GetComponent<Item>());
			AOE[] array = Object.FindObjectsByType<AOE>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				if (!__state.Contains(((Object)array[i]).GetInstanceID()))
				{
					((Component)array[i]).gameObject.AddComponent<PeakVsOwnedEffect>().OwnerActor = logicalOwnerActor;
				}
			}
		}
	}
	[HarmonyPatch(typeof(AOE), "Explode")]
	internal static class OwnedAreaEffectPatch
	{
		private static bool Prefix(AOE __instance, out List<Collider> __state)
		{
			__state = null;
			if (!GameMode.IsActive)
			{
				return true;
			}
			PeakVsOwnedEffect component = ((Component)__instance).GetComponent<PeakVsOwnedEffect>();
			if ((Object)(object)component == (Object)null || component.OwnerActor <= 0)
			{
				return true;
			}
			Player localPlayer = PhotonNetwork.LocalPlayer;
			int num = ((localPlayer != null) ? localPlayer.ActorNumber : 0);
			if (component.OwnerActor != num)
			{
				return false;
			}
			__state = new List<Collider>();
			List<Character> allPlayerCharacters = PlayerHandler.GetAllPlayerCharacters();
			for (int i = 0; i < allPlayerCharacters.Count; i++)
			{
				Character val = allPlayerCharacters[i];
				if ((Object)(object)val == (Object)null || (Object)(object)((MonoBehaviourPun)val).photonView == (Object)null || ((MonoBehaviourPun)val).photonView.OwnerActorNr == component.OwnerActor)
				{
					continue;
				}
				Collider[] componentsInChildren = ((Component)val).GetComponentsInChildren<Collider>(true);
				for (int j = 0; j < componentsInChildren.Length; j++)
				{
					if ((Object)(object)componentsInChildren[j] != (Object)null && componentsInChildren[j].enabled)
					{
						componentsInChildren[j].enabled = false;
						__state.Add(componentsInChildren[j]);
					}
				}
			}
			return true;
		}

		private static Exception Finalizer(Exception __exception, List<Collider> __state)
		{
			if (__state != null)
			{
				for (int i = 0; i < __state.Count; i++)
				{
					if ((Object)(object)__state[i] != (Object)null)
					{
						__state[i].enabled = true;
					}
				}
			}
			return __exception;
		}
	}
	[BepInPlugin("dev.peakvs.racemode", "PeakVs", "0.7.2")]
	[BepInProcess("PEAK.exe")]
	public sealed class PeakVsPlugin : BaseUnityPlugin, IOnEventCallback
	{
		public const string PluginGuid = "dev.peakvs.racemode";

		public const string PluginName = "PeakVs";

		public const string PluginVersion = "0.7.2";

		private Harmony _harmony;

		internal static PeakVsPlugin Instance { get; private set; }

		internal static ManualLogSource Log { get; private set; }

		internal static ConfigEntry<float> RemoteScoutOpacity { get; private set; }

		internal static ConfigEntry<bool> ShowRaceHud { get; private set; }

		internal static ConfigEntry<float> HudScale { get; private set; }

		internal static ConfigEntry<KeyCode> MenuToggleKey { get; private set; }

		internal static ConfigEntry<KeyCode> CompactHudToggleKey { get; private set; }

		internal static ConfigEntry<bool> CompactRaceHud { get; private set; }

		internal static ConfigEntry<bool> AutoLightCheckpoints { get; private set; }

		internal static ConfigEntry<bool> MatchedLuggageLoot { get; private set; }

		private void Awake()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			RemoteScoutOpacity = ((BaseUnityPlugin)this).Config.Bind<float>("Visuals", "RemoteScoutOpacity", 0.45f, "Opacity used for the other racers (0.15 to 0.9).");
			ShowRaceHud = ((BaseUnityPlugin)this).Config.Bind<bool>("HUD", "ShowRaceHud", true, "Show the synchronized biome timer and racer results.");
			HudScale = ((BaseUnityPlugin)this).Config.Bind<float>("HUD", "HudScale", 1f, new ConfigDescription("Scale of the race timer and standings.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.7f, 1.5f), Array.Empty<object>()));
			MenuToggleKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("HUD", "MenuToggleKey", (KeyCode)287, "Key used to open the PeakVs menu.");
			CompactHudToggleKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("HUD", "CompactHudToggleKey", (KeyCode)288, "Key used to toggle between full standings and the compact personal split timer.");
			CompactRaceHud = ((BaseUnityPlugin)this).Config.Bind<bool>("HUD", "CompactRaceHud", false, "Show only your own live or completed split time.");
			AutoLightCheckpoints = ((BaseUnityPlugin)this).Config.Bind<bool>("Race", "AutoLightCheckpoints", true, "Automatically light a campfire when every racer has finished or forfeited the biome.");
			MatchedLuggageLoot = ((BaseUnityPlugin)this).Config.Bind<bool>("Race", "MatchedLuggageLoot", true, "Host setting: give every racer the same deterministic item roll from each luggage container.");
			RaceSession.Initialize();
			_harmony = new Harmony("dev.peakvs.racemode");
			_harmony.PatchAll(typeof(PeakVsPlugin).Assembly);
			NetworkContextPatcher.Install(_harmony);
			RaceHud.Initialize();
			HostMenu.Initialize();
			PhotonNetwork.AddCallbackTarget((object)this);
			SceneManager.sceneLoaded += OnSceneLoaded;
			Log.LogInfo((object)("PeakVs 0.7.2 loaded for PEAK " + Application.version + "."));
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			PhotonNetwork.RemoveCallbackTarget((object)this);
			GameMode.ClearPresence();
			HostMenu.Dispose();
			RaceHud.Dispose();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			RaceSession.ResetForScene(SceneHandle.op_Implicit(((Scene)(ref scene)).handle));
			PrivateLoot.ResetForScene();
			PeakVsUi.OnSceneLoaded();
		}

		private void Update()
		{
			GameMode.TickPresence();
			RaceSession.Tick();
			PrivateLoot.Tick();
			RaceHud.Tick();
			HostMenu.Tick();
		}

		public void OnEvent(EventData photonEvent)
		{
			PrivateLoot.OnPhotonEvent(photonEvent);
		}
	}
	internal static class PeakVsUi
	{
		internal static readonly Color PanelColor = new Color(0.025f, 0.045f, 0.065f, 0.94f);

		internal static readonly Color RowColor = new Color(0.075f, 0.11f, 0.14f, 0.86f);

		internal static readonly Color TextColor = new Color(0.92f, 0.96f, 0.98f, 1f);

		internal static readonly Color MutedColor = new Color(0.58f, 0.68f, 0.72f, 1f);

		internal static readonly Color AccentColor = new Color(0.16f, 0.85f, 0.94f, 1f);

		internal static readonly Color WarmColor = new Color(1f, 0.57f, 0.16f, 1f);

		internal static readonly Color DangerColor = new Color(1f, 0.35f, 0.28f, 1f);

		private static TMP_FontAsset _gameFont;

		private static TMP_FontAsset _fallbackFont;

		private static float _nextFontSearch;

		private static float _nextResourceFontSearch;

		private static int _fontRevision;

		internal static int FontRevision
		{
			get
			{
				GetFont();
				return _fontRevision;
			}
		}

		internal static Canvas CreateCanvas(string name, int sortingOrder, bool interactive)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			int num = LayerMask.NameToLayer("UI");
			if (num >= 0)
			{
				val.layer = num;
			}
			Canvas obj = val.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = sortingOrder;
			CanvasScaler obj2 = val.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = new Vector2(1920f, 1080f);
			obj2.screenMatchMode = (ScreenMatchMode)0;
			obj2.matchWidthOrHeight = 0.5f;
			if (interactive)
			{
				val.AddComponent<GraphicRaycaster>();
			}
			Object.DontDestroyOnLoad((Object)(object)val);
			return obj;
		}

		internal static Image CreateImage(Transform parent, string name, Color color)
		{
			//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_002c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			Image obj = val.AddComponent<Image>();
			((Graphic)obj).color = color;
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		internal static TextMeshProUGUI CreateText(Transform parent, string name, float size, TextAlignmentOptions alignment, Color color)
		{
			//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_003e: 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)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			TextMeshProUGUI obj = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj).font = GetFont();
			((TMP_Text)obj).fontSize = size;
			((TMP_Text)obj).alignment = alignment;
			((Graphic)obj).color = color;
			((Graphic)obj).raycastTarget = false;
			((TMP_Text)obj).richText = false;
			((TMP_Text)obj).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)obj).overflowMode = (TextOverflowModes)1;
			return obj;
		}

		internal static void ApplyFont(TMP_Text text)
		{
			TMP_FontAsset font = GetFont();
			if ((Object)(object)text != (Object)null && (Object)(object)font != (Object)null && (Object)(object)text.font != (Object)(object)font)
			{
				text.font = font;
			}
		}

		internal static void SetRect(RectTransform rect, Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 position, Vector2 size)
		{
			//IL_0001: 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_000f: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = anchorMin;
			rect.anchorMax = anchorMax;
			rect.pivot = pivot;
			rect.anchoredPosition = position;
			rect.sizeDelta = size;
		}

		internal static void OnSceneLoaded()
		{
			_nextFontSearch = 0f;
		}

		private static TMP_FontAsset GetFont()
		{
			if ((Object)(object)_gameFont != (Object)null)
			{
				return _gameFont;
			}
			if (Time.unscaledTime >= _nextFontSearch)
			{
				_nextFontSearch = Time.unscaledTime + 3f;
				TryFindGameFont();
			}
			if ((Object)(object)_gameFont != (Object)null)
			{
				return _gameFont;
			}
			if ((Object)(object)_fallbackFont == (Object)null)
			{
				try
				{
					_fallbackFont = Resources.Load<TMP_FontAsset>("Fonts & Materials/LiberationSans SDF");
				}
				catch
				{
				}
			}
			return _fallbackFont;
		}

		private static void TryFindGameFont()
		{
			try
			{
				if ((Object)(object)GUIManager.instance != (Object)null && (Object)(object)GUIManager.instance.heroText != (Object)null && (Object)(object)((TMP_Text)GUIManager.instance.heroText).font != (Object)null)
				{
					_gameFont = ((TMP_Text)GUIManager.instance.heroText).font;
					_fontRevision++;
					return;
				}
			}
			catch
			{
			}
			if (Time.unscaledTime < _nextResourceFontSearch)
			{
				return;
			}
			_nextResourceFontSearch = Time.unscaledTime + 15f;
			TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
			foreach (TMP_FontAsset val in array)
			{
				if ((Object)(object)val != (Object)null && ((Object)val).name.IndexOf("Daruma", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					_gameFont = val;
					_fontRevision++;
					break;
				}
			}
		}
	}
	internal static class PrivateLoot
	{
		private sealed class PendingPickup
		{
			internal Item Item;

			internal float StartedAt;
		}

		private sealed class PendingSharedClone
		{
			internal Item Item;

			internal int InstanceId;

			internal float QueuedAt;
		}

		private const byte PickupRequestEvent = 176;

		private const byte PickupResponseEvent = 177;

		private const byte OwnedVisualEvent = 178;

		private const int PrivateGroupBase = 128;

		private static readonly Dictionary<int, PendingPickup> PendingPickups = new Dictionary<int, PendingPickup>();

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

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

		private static readonly Queue<PendingSharedClone> PendingSharedClones = new Queue<PendingSharedClone>();

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

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

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

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

		private static readonly FieldInfo LuggageStateField = AccessTools.Field(typeof(Luggage), "state");

		private static readonly MethodInfo GetSpawnSpotsMethod = AccessTools.Method(typeof(Spawner), "GetSpawnSpots", (Type[])null, (Type[])null);

		private static readonly MethodInfo GetObjectsToSpawnMethod = AccessTools.Method(typeof(Spawner), "GetObjectsToSpawn", (Type[])null, (Type[])null);

		private static readonly MethodInfo OffsetSpawnMethod = AccessTools.Method(typeof(Spawner), "OffsetSpawn", (Type[])null, (Type[])null);

		private static readonly MethodInfo ForceSyncMethod = AccessTools.Method(typeof(Item), "ForceSyncForFrames", (Type[])null, (Type[])null);

		private static readonly FieldInfo UtilRandomField = AccessTools.Field(typeof(Util), "r");

		private static int _groupActorNumber = -1;

		private static float _nextSharedCloneTick;

		private static float _nextOwnedVisualTick;

		private static float _nextDynamicVisualTick;

		internal static byte LocalGroup
		{
			get
			{
				Player localPlayer = PhotonNetwork.LocalPlayer;
				int num = ((localPlayer == null) ? 1 : localPlayer.ActorNumber);
				if (num > 127)
				{
					num = (num - 1) % 127 + 1;
				}
				return (byte)(128 + num);
			}
		}

		internal static bool IsPrivateGroup(byte group)
		{
			return group > 128;
		}

		internal static bool IsPrivate(Item item)
		{
			if ((Object)(object)item != (Object)null && (Object)(object)((MonoBehaviourPun)item).photonView != (Object)null)
			{
				return IsPrivateGroup(((MonoBehaviourPun)item).photonView.Group);
			}
			return false;
		}

		internal static int GetLogicalOwnerActor(Item item)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			//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_0041: 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)item == (Object)null || (Object)(object)((MonoBehaviourPun)item).photonView == (Object)null)
			{
				return 0;
			}
			try
			{
				if ((int)item.itemState == 2 && item.backpackReference.IsSome)
				{
					BackpackReference item2 = item.backpackReference.Value.Item2;
					if ((Object)(object)item2.view != (Object)null)
					{
						return GetLogicalOwnerActor(item2.view);
					}
				}
			}
			catch
			{
			}
			return GetLogicalOwnerActor(((MonoBehaviourPun)item).photonView);
		}

		internal static int GetLogicalOwnerActor(PhotonView view)
		{
			if ((Object)(object)view == (Object)null)
			{
				return 0;
			}
			if (OwnedVisualActors.TryGetValue(view.ViewID, out var value))
			{
				return value;
			}
			return view.OwnerActorNr;
		}

		internal static bool TryGetRegisteredOwnedVisualActor(PhotonView view, out int ownerActor)
		{
			ownerActor = 0;
			if ((Object)(object)view != (Object)null && view.ViewID > 0 && OwnedVisualActors.TryGetValue(view.ViewID, out ownerActor))
			{
				return ownerActor > 0;
			}
			return false;
		}

		internal static void RegisterOwnedVisual(GameObject spawnedObject, int ownerActor)
		{
			//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_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_00be: Expected O, but got Unknown
			if (!GameMode.IsActive || (Object)(object)spawnedObject == (Object)null || ownerActor <= 0)
			{
				return;
			}
			PhotonView component = spawnedObject.GetComponent<PhotonView>();
			if (!((Object)(object)component == (Object)null) && component.ViewID > 0 && component.Group == 0)
			{
				OwnedVisualActors[component.ViewID] = ownerActor;
				PendingOwnedVisualViews.Remove(component.ViewID);
				TrackDynamicOwnedVisual(component);
				RaceSession.ApplyOwnedVisual(component);
				if (PhotonNetwork.InRoom && AnnouncedOwnedViews.Add(component.ViewID))
				{
					PhotonNetwork.RaiseEvent((byte)178, (object)new object[2] { component.ViewID, ownerActor }, new RaiseEventOptions
					{
						Receivers = (ReceiverGroup)1,
						CachingOption = (EventCaching)4
					}, SendOptions.SendReliable);
				}
			}
		}

		internal static void UnregisterOwnedVisual(int viewId, int ownerActor)
		{
			//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_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_0084: Expected O, but got Unknown
			if (viewId > 0)
			{
				if (OwnedVisualActors.TryGetValue(viewId, out var value) && value == ownerActor)
				{
					OwnedVisualActors.Remove(viewId);
				}
				PendingOwnedVisualViews.Remove(viewId);
				DynamicOwnedVisualViews.Remove(viewId);
				if (AnnouncedOwnedViews.Remove(viewId) && PhotonNetwork.InRoom)
				{
					PhotonNetwork.RaiseEvent((byte)178, (object)new object[2] { viewId, ownerActor }, new RaiseEventOptions
					{
						CachingOption = (EventCaching)6
					}, SendOptions.SendReliable);
				}
			}
		}

		internal static bool IsOwnedByLocal(Item item)
		{
			if ((Object)(object)item == (Object)null || PhotonNetwork.LocalPlayer == null)
			{
				return false;
			}
			if (IsPrivate(item))
			{
				return ((MonoBehaviourPun)item).photonView.Group == LocalGroup;
			}
			if (TryGetRegisteredOwnedVisualActor(((MonoBehaviourPun)item).photonView, out var ownerActor))
			{
				return ownerActor == PhotonNetwork.LocalPlayer.ActorNumber;
			}
			return false;
		}

		internal static bool IsRivalOwned(Item item)
		{
			if (GameMode.IsActive && (Object)(object)item != (Object)null && !IsPrivate(item) && PhotonNetwork.LocalPlayer != null && TryGetRegisteredOwnedVisualActor(((MonoBehaviourPun)item).photonView, out var ownerActor))
			{
				return ownerActor != PhotonNetwork.LocalPlayer.ActorNumber;
			}
			return false;
		}

		internal static bool CanUseOwnedVisual(Component component, Character interactor)
		{
			if (!GameMode.IsActive || (Object)(object)component == (Object)null)
			{
				return true;
			}
			int ownerActor = 0;
			if (!TryGetRegisteredOwnedVisualActor(component.GetComponentInParent<PhotonView>(), out ownerActor))
			{
				PeakVsOwnedObject componentInParent = component.GetComponentInParent<PeakVsOwnedObject>();
				if ((Object)(object)componentInParent != (Object)null && componentInParent.OwnerActor > 0)
				{
					ownerActor = componentInParent.OwnerActor;
				}
				else
				{
					BackpackOnBackVisuals componentInParent2 = component.GetComponentInParent<BackpackOnBackVisuals>();
					Character val = (((Object)(object)componentInParent2 != (Object)null) ? componentInParent2.character : null);
					if ((Object)(object)val == (Object)null || (Object)(object)((MonoBehaviourPun)val).photonView == (Object)null)
					{
						return true;
					}
					ownerActor = ((MonoBehaviourPun)val).photonView.OwnerActorNr;
				}
			}
			int num;
			if (!((Object)(object)interactor != (Object)null) || !((Object)(object)((MonoBehaviourPun)interactor).photonView != (Object)null))
			{
				Player localPlayer = PhotonNetwork.LocalPlayer;
				num = ((localPlayer != null) ? localPlayer.ActorNumber : 0);
			}
			else
			{
				num = ((MonoBehaviourPun)interactor).photonView.OwnerActorNr;
			}
			int num2 = num;
			if (num2 > 0)
			{
				return ownerActor == num2;
			}
			return true;
		}

		internal static bool CanAccessBackpack(Character backpackOwner, Character interactor)
		{
			if (!GameMode.IsActive)
			{
				return true;
			}
			if ((Object)(object)backpackOwner != (Object)null && (Object)(object)interactor != (Object)null)
			{
				if (!((Object)(object)backpackOwner == (Object)(object)interactor))
				{
					return backpackOwner.isBot;
				}
				return true;
			}
			return false;
		}

		internal static bool CanAccessBackpack(BackpackReference backpack, Character interactor)
		{
			//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_000e: Invalid comparison between Unknown and I4
			//IL_0012: 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)
			if (!GameMode.IsActive || (int)backpack.type != 1)
			{
				return true;
			}
			return CanAccessBackpack(((Object)(object)backpack.view != (Object)null) ? ((Component)backpack.view).GetComponent<Character>() : null, interactor);
		}

		internal static void ResetForScene()
		{
			QueuedSharedItems.Clear();
			PendingSharedClones.Clear();
			PendingPickups.Clear();
			OwnedVisualActors.Clear();
			PendingOwnedVisualViews.Clear();
			DynamicOwnedVisualViews.Clear();
			AnnouncedOwnedViews.Clear();
			ScratchIds.Clear();
			_nextSharedCloneTick = 0f;
			_nextOwnedVisualTick = 0f;
			_nextDynamicVisualTick = 0f;
		}

		internal static void EnsurePrivateGroup()
		{
			if (!PhotonNetwork.InRoom || PhotonNetwork.LocalPlayer == null)
			{
				_groupActorNumber = -1;
				return;
			}
			int actorNumber = PhotonNetwork.LocalPlayer.ActorNumber;
			if (_groupActorNumber != actorNumber)
			{
				_groupActorNumber = actorNumber;
				PhotonNetwork.SetInterestGroups(LocalGroup, true);
				PeakVsPlugin.Log.LogInfo((object)$"Enabled private Photon group {LocalGroup} for actor {actorNumber}.");
				if (actorNumber > 127)
				{
					PeakVsPlugin.Log.LogWarning((object)"Actor number exceeds PeakVs' unique private-group range; item isolation may collide.");
				}
			}
		}

		internal static void Tick()
		{
			TickPendingPickups();
			TickSharedItemClones();
			TickOwnedVisuals();
		}

		private static void TickPendingPickups()
		{
			if (PendingPickups.Count == 0)
			{
				return;
			}
			ScratchIds.Clear();
			foreach (KeyValuePair<int, PendingPickup> pendingPickup in PendingPickups)
			{
				if (!(Time.unscaledTime - pendingPickup.Value.StartedAt <= 6f))
				{
					ScratchIds.Add(pendingPickup.Key);
					RestorePendingItem(pendingPickup.Value.Item);
				}
			}
			if (ScratchIds.Count != 0)
			{
				for (int i = 0; i < ScratchIds.Count; i++)
				{
					PendingPickups.Remove(ScratchIds[i]);
				}
				PeakVsPlugin.Log.LogWarning((object)"A private pickup request timed out; the item was restored.");
			}
		}

		internal static bool OpenLuggage(Luggage luggage, Character interactor)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!GameMode.IsActive || (Object)(object)luggage == (Object)null || (Object)(object)interactor == (Object)null || !interactor.IsLocal)
			{
				return false;
			}
			if ((int)(LuggageState)LuggageStateField.GetValue(luggage) != 0)
			{
				return true;
			}
			LuggageStateField.SetValue(luggage, (object)(LuggageState)1);
			Animator component = ((Component)luggage).GetComponent<Animator>();
			if (component != null)
			{
				component.Play("Luggage_Open");
			}
			Luggage.ALL_LUGGAGE.Remove(luggage);
			if ((Object)(object)luggage.activateOnOpen != (Object)null)
			{
				luggage.activateOnOpen.SetActive(true);
			}
			RespawnChest val = (RespawnChest)(object)((luggage is RespawnChest) ? luggage : null);
			if ((Object)(object)val != (Object)null)
			{
				if ((Object)(object)val.skeleton != (Object)null)
				{
					val.skeleton.SetActive(false);
				}
				SpawnLuggageContents((Luggage)(object)val);
			}
			else
			{
				SpawnLuggageContents(luggage);
			}
			GlobalEvents.TriggerLuggageOpened(luggage, interactor);
			return true;
		}

		private static void SpawnLuggageContents(Luggage luggage)
		{
			//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_0247: 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_01a7: 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_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_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			State state = Random.state;
			Random value = UtilRandomField?.GetValue(null) as Random;
			try
			{
				int num = ((RaceSession.Stage >= 0) ? RaceSession.Stage : 0);
				int num2 = (((Object)(object)((MonoBehaviourPun)luggage).photonView != (Object)null) ? ((MonoBehaviourPun)luggage).photonView.ViewID : ((Object)luggage).GetInstanceID());
				int num3;
				if (!RaceSession.SameLuggageLoot)
				{
					Player localPlayer = PhotonNetwork.LocalPlayer;
					num3 = ((localPlayer != null) ? localPlayer.ActorNumber : 0) * 104729;
				}
				else
				{
					num3 = 0;
				}
				int num4 = num3;
				int num5 = (num2 * 397) ^ (num * 7919) ^ num4 ^ 0x50EA5;
				Random.InitState(num5);
				UtilRandomField?.SetValue(null, new Random(num5));
				List<Transform> list = (List<Transform>)GetSpawnSpotsMethod.Invoke(luggage, null);
				List<GameObject> list2 = (List<GameObject>)GetObjectsToSpawnMethod.Invoke(luggage, new object[2]
				{
					list.Count,
					((Spawner)luggage).canRepeatSpawns
				});
				if (list2 == null)
				{
					return;
				}
				int num6 = Math.Min(list.Count, list2.Count);
				for (int i = 0; i < num6; i++)
				{
					GameObject val = list2[i];
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					Item component = val.GetComponent<Item>();
					if ((Object)(object)component == (Object)null || IsForbidden(component))
					{
						continue;
					}
					Transform val2 = list[i];
					Item val3 = SpawnPrivateItem(((Object)val).name, val2.position, val2.rotation, null, ((Spawner)luggage).isKinematic);
					if (!((Object)(object)val3 == (Object)null))
					{
						if ((Object)(object)((Spawner)luggage).spawnUpTowardsTarget != (Object)null)
						{
							Transform transform = ((Component)val3).transform;
							Vector3 val4 = ((Spawner)luggage).spawnUpTowardsTarget.position - ((Component)val3).transform.position;
							transform.up = ((Vector3)(ref val4)).normalized;
						}
						if (((Spawner)luggage).centerItemsVisually)
						{
							Transform transform2 = ((Component)val3).transform;
							transform2.position += val2.position - val3.Center();
						}
						OffsetSpawnMethod.Invoke(luggage, new object[1] { val3 });
						InitializeSpawnedItem((Spawner)(object)luggage, val3);
					}
				}
			}
			catch (Exception arg)
			{
				PeakVsPlugin.Log.LogError((object)$"Failed to create private luggage loot: {arg}");
			}
			finally
			{
				Random.state = state;
				UtilRandomField?.SetValue(null, value);
			}
		}

		private static void InitializeSpawnedItem(Spawner spawner, Item item)
		{
			//IL_0056: 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_0096: 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_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_00b8: 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_00d2: 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_00e6: 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)
			ForceSyncMethod?.Invoke(item, new object[1] { 10 });
			if (spawner.isKinematic || item.CarryWeight < 0)
			{
				((MonoBehaviourPun)item).photonView.RPC("SetKinematicRPC", (RpcTarget)3, new object[3]
				{
					true,
					((Component)item).transform.position,
					((Component)item).transform.rotation
				});
			}
			else if (spawner.spawnWithForce && (Object)(object)spawner.spawnUpTowardsTarget != (Object)null)
			{
				Vector3 val = ((Component)item).transform.position - spawner.spawnUpTowardsTarget.position;
				Vector3 val2 = ((Vector3)(ref val)).normalized + Vector3.up;
				((MonoBehaviourPun)item).photonView.RPC("ApplyForceRPC", (RpcTarget)3, new object[2]
				{
					val2 * spawner.spawnForce,
					Random.onUnitSphere * spawner.spawnTorque
				});
			}
		}

		internal static Item SpawnPrivateItem(string prefabName, Vector3 position, Quaternion rotation, ItemInstanceData data, bool isKinematic)
		{
			//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_0082: 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)
			EnsurePrivateGroup();
			GameObject val = PhotonNetwork.Instantiate("0_Items/" + StripCloneSuffix(prefabName), position, rotation, LocalGroup, (object[])null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Item component = val.GetComponent<Item>();
			if ((Object)(object)component == (Object)null)
			{
				PhotonNetwork.Destroy(val);
				return null;
			}
			if (data != null)
			{
				((MonoBehaviourPun)component).photonView.RPC("SetItemInstanceDataRPC", (RpcTarget)0, new object[1] { data });
			}
			((MonoBehaviourPun)component).photonView.RPC("SetKinematicRPC", (RpcTarget)3, new object[3] { isKinematic, position, rotation });
			return component;
		}

		internal static void QueueSharedItemClone(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			PhotonView photonView = ((MonoBehaviourPun)item).photonView;
			if (!((Object)(object)photonView != (Object)null) || photonView.ViewID <= 0 || (photonView.Group == 0 && photonView.IsRoomView))
			{
				int instanceID = ((Object)item).GetInstanceID();
				if (QueuedSharedItems.Add(instanceID))
				{
					PendingSharedClones.Enqueue(new PendingSharedClone
					{
						Item = item,
						InstanceId = instanceID,
						QueuedAt = Time.unscaledTime
					});
				}
			}
		}

		private static void TickSharedItemClones()
		{
			if (!GameMode.IsActive || PendingSharedClones.Count == 0 || Time.unscaledTime < _nextSharedCloneTick)
			{
				return;
			}
			_nextSharedCloneTick = Time.unscaledTime + 0.1f;
			int num = Math.Min(24, PendingSharedClones.Count);
			for (int i = 0; i < num; i++)
			{
				PendingSharedClone pendingSharedClone = PendingSharedClones.Dequeue();
				Item item = pendingSharedClone.Item;
				if ((Object)(object)item == (Object)null)
				{
					QueuedSharedItems.Remove(pendingSharedClone.InstanceId);
					continue;
				}
				if (Time.unscaledTime - pendingSharedClone.QueuedAt < 0.75f)
				{
					PendingSharedClones.Enqueue(pendingSharedClone);
					continue;
				}
				if (((Object)(object)((MonoBehaviourPun)item).photonView == (Object)null || ((MonoBehaviourPun)item).photonView.ViewID <= 0) && Time.unscaledTime - pendingSharedClone.QueuedAt < 6f)
				{
					PendingSharedClones.Enqueue(pendingSharedClone);
					continue;
				}
				QueuedSharedItems.Remove(pendingSharedClone.InstanceId);
				ProcessSharedItemClone(item);
			}
		}

		private static void ProcessSharedItemClone(Item original)
		{
			//IL_0033: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)original == (Object)null || (Object)(object)((MonoBehaviourPun)original).photonView == (Object)null || ((MonoBehaviourPun)original).photonView.Group != 0 || !((MonoBehaviourPun)original).photonView.IsRoomView || (int)original.itemState != 0 || TryGetRegisteredOwnedVisualActor(((MonoBehaviourPun)original).photonView, out var _))
			{
				return;
			}
			if (IsForbidden(original))
			{
				HideSharedItem(original);
				if (PhotonNetwork.IsMasterClient)
				{
					PhotonNetwork.Destroy(((MonoBehaviourPun)original).photonView);
				}
			}
			else
			{
				Item val = default(Item);
				string text = (ItemDatabase.TryGetItem(original.itemID, ref val) ? ((Object)((Component)val).gameObject).name : StripCloneSuffix(((Object)((Component)original).gameObject).name));
				if ((Object)(object)SpawnPrivateItem(text, ((Component)original).transform.position, ((Component)original).transform.rotation, original.data, (Object)(object)original.rig != (Object)null && original.rig.isKinematic) == (Object)null)
				{
					PeakVsPlugin.Log.LogWarning((object)("Could not privately clone shared item " + text + "; leaving it shared."));
				}
				else
				{
					HideSharedItem(original);
				}
			}
		}

		private static void TickOwnedVisuals()
		{
			if (!GameMode.IsActive)
			{
				return;
			}
			if (PendingOwnedVisualViews.Count > 0 && Time.unscaledTime >= _nextOwnedVisualTick)
			{
				_nextOwnedVisualTick = Time.unscaledTime + 0.2f;
				ScratchIds.Clear();
				foreach (KeyValuePair<int, float> pendingOwnedVisualView in PendingOwnedVisualViews)
				{
					PhotonView photonView = PhotonNetwork.GetPhotonView(pendingOwnedVisualView.Key);
					if ((Object)(object)photonView != (Object)null)
					{
						TrackDynamicOwnedVisual(photonView);
						RaceSession.ApplyOwnedVisual(photonView);
						ScratchIds.Add(pendingOwnedVisualView.Key);
					}
					else if (Time.unscaledTime >= pendingOwnedVisualView.Value)
					{
						ScratchIds.Add(pendingOwnedVisualView.Key);
						OwnedVisualActors.Remove(pendingOwnedVisualView.Key);
					}
				}
				for (int i = 0; i < ScratchIds.Count; i++)
				{
					PendingOwnedVisualViews.Remove(ScratchIds[i]);
				}
			}
			if (Time.unscaledTime < _nextDynamicVisualTick)
			{
				return;
			}
			_nextDynamicVisualTick = Time.unscaledTime + 1f;
			ScratchIds.Clear();
			foreach (int dynamicOwnedVisualView in DynamicOwnedVisualViews)
			{
				PhotonView photonView2 = PhotonNetwork.GetPhotonView(dynamicOwnedVisualView);
				if ((Object)(object)photonView2 == (Object)null)
				{
					ScratchIds.Add(dynamicOwnedVisualView);
					continue;
				}
				Rope val = (((Object)(object)photonView2 != (Object)null) ? ((Component)photonView2).GetComponent<Rope>() : null);
				if ((Object)(object)val != (Object)null)
				{
					RaceSession.RefreshOwnedVisual(photonView2, val.SegmentCount);
				}
			}
			for (int j = 0; j < ScratchIds.Count; j++)
			{
				DynamicOwnedVisualViews.Remove(ScratchIds[j]);
				OwnedVisualActors.Remove(ScratchIds[j]);
			}
		}

		private static void TrackDynamicOwnedVisual(PhotonView view)
		{
			if ((Object)(object)view != (Object)null && (Object)(object)((Component)view).GetComponent<Rope>() != (Object)null)
			{
				DynamicOwnedVisualViews.Add(view.ViewID);
			}
		}

		private static void HideSharedItem(Item item)
		{
			if ((Object)(object)item != (Object)null)
			{
				item.blockInteraction = true;
				((Component)item).gameObject.SetActive(false);
			}
		}

		internal static bool RequestPickup(Item item, Character interactor)
		{
			//IL_013b: 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_0142: 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_0151: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Invalid comparison between Unknown and I4
			if (!IsPrivate(item) || (Object)(object)interactor == (Object)null || !interactor.IsLocal)
			{
				return false;
			}
			if (!interactor.player.HasEmptySlot(item.itemID) || interactor.refs.items.lastEquippedSlotTime + 0.25f > Time.time)
			{
				return true;
			}
			GlobalEvents.TriggerItemRequested(item, interactor);
			ushort num = (((Object)(object)item.isSecretlyOtherItemPrefab != (Object)null) ? item.isSecretlyOtherItemPrefab.itemID : item.itemID);
			if (PhotonNetwork.IsMasterClient)
			{
				ItemSlot val = default(ItemSlot);
				if (interactor.player.AddItem(num, item.data, ref val))
				{
					if ((int)item.itemState == 2 && item.backpackReference.IsSome)
					{
						item.ClearDataFromBackpack();
					}
					else
					{
						PhotonNetwork.Destroy(((MonoBehaviourPun)item).photonView);
					}
					interactor.refs.items.OnPickupAccepted(val.itemSlotID);
				}
				return true;
			}
			int viewID = ((MonoBehaviourPun)item).photonView.ViewID;
			item.blockInteraction = true;
			((Component)item).gameObject.SetActive(false);
			PendingPickups[viewID] = new PendingPickup
			{
				Item = item,
				StartedAt = Time.unscaledTime
			};
			PhotonNetwork.RaiseEvent((byte)176, (object)new object[3]
			{
				viewID,
				(int)num,
				item.data
			}, new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)2
			}, SendOptions.SendReliable);
			return true;
		}

		internal static void OnPhotonEvent(EventData photonEvent)
		{
			if (photonEvent.Code == 178)
			{
				if (photonEvent.CustomData is object[] array && array.Length >= 2)
				{
					int num = Convert.ToInt32(array[0]);
					OwnedVisualActors[num] = Convert.ToInt32(array[1]);
					PhotonView photonView = PhotonNetwork.GetPhotonView(num);
					if ((Object)(object)photonView != (Object)null)
					{
						TrackDynamicOwnedVisual(photonView);
						RaceSession.ApplyOwnedVisual(photonView);
					}
					else
					{
						PendingOwnedVisualViews[num] = Time.unscaledTime + 10f;
					}
				}
			}
			else if (photonEvent.Code == 176 && PhotonNetwork.IsMasterClient && GameMode.IsActive)
			{
				HandlePickupRequest(photonEvent);
			}
			else if (photonEvent.Code == 177)
			{
				HandlePickupResponse(photonEvent);
			}
		}

		private static void HandlePickupRequest(EventData photonEvent)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			if (!(photonEvent.CustomData is object[] array) || array.Length < 3)
			{
				return;
			}
			int num = Convert.ToInt32(array[0]);
			ushort num2 = Convert.ToUInt16(array[1]);
			object obj = array[2];
			ItemInstanceData val = (ItemInstanceData)((obj is ItemInstanceData) ? obj : null);
			bool flag = false;
			byte b = byte.MaxValue;
			Room currentRoom = PhotonNetwork.CurrentRoom;
			Player val2 = ((currentRoom != null) ? currentRoom.GetPlayer(photonEvent.Sender, false) : null);
			Player val3 = ((val2 == null) ? null : PlayerHandler.GetPlayer(val2));
			if ((Object)(object)val3 != (Object)null)
			{
				ItemSlot val4 = default(ItemSlot);
				flag = val3.AddItem(num2, val, ref val4);
				if (flag)
				{
					b = val4.itemSlotID;
				}
			}
			object[] obj2 = new object[3] { num, flag, b };
			RaiseEventOptions val5 = new RaiseEventOptions();
			val5.TargetActors = new int[1] { photonEvent.Sender };
			PhotonNetwork.RaiseEvent((byte)177, (object)obj2, val5, SendOptions.SendReliable);
		}

		private static void HandlePickupResponse(EventData photonEvent)
		{
			if (!(photonEvent.CustomData is object[] array) || array.Length < 3)
			{
				return;
			}
			int key = Convert.ToInt32(array[0]);
			bool flag = Convert.ToBoolean(array[1]);
			byte b = Convert.ToByte(array[2]);
			if (!PendingPickups.TryGetValue(key, out var value))
			{
				return;
			}
			PendingPickups.Remove(key);
			if (!GameMode.IsActive)
			{
				RestorePendingItem(value.Item);
				return;
			}
			if (!flag)
			{
				RestorePendingItem(value.Item);
				return;
			}
			if ((Object)(object)value.Item != (Object)null && (Object)(object)((MonoBehaviourPun)value.Item).photonView != (Object)null)
			{
				PhotonNetwork.Destroy(((MonoBehaviourPun)value.Item).photonView);
			}
			Character localCharacter = Character.localCharacter;
			if (localCharacter != null)
			{
				localCharacter.refs.items.OnPickupAccepted(b);
			}
		}

		private static void RestorePendingItem(Item item)
		{
			if ((Object)(object)item != (Object)null)
			{
				((Component)item).gameObject.SetActive(true);
				item.blockInteraction = false;
			}
		}

		internal static bool IsForbidden(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			switch (Normalize(((Object)((Component)item).gameObject).name))
			{
			case "cursedskull":
			case "scouteffigy":
			case "scoutmasterbugle":
			case "buglescoutmastervariant":
				return true;
			default:
			{
				LootData component = ((Component)item).GetComponent<LootData>();
				if ((Object)(object)component != (Object)null && component.banInSolo)
				{
					return true;
				}
				if (!((Object)(object)((Component)item).GetComponent<RespawnRandomScout>() != (Object)null) && !((Object)(object)((Component)item).GetComponent<ScoutEffigy>() != (Object)null) && !((Object)(object)((Component)item).GetComponent<Action_WarpToRandomPlayer>() != (Object)null) && !((Object)(object)((Component)item).GetComponent<Action_CallScoutmaster>() != (Object)null))
				{
					return (Object)(object)((Component)item).GetComponent<Action_ApplyMassAffliction>() != (Object)null;
				}
				return true;
			}
			}
		}

		private static string Normalize(string value)
		{
			return StripCloneSuffix(value).Replace(" ", string.Empty).Replace("_", string.Empty).ToLowerInvariant();
		}

		private static string StripCloneSuffix(string value)
		{
			if (value == null || !value.EndsWith("(Clone)", StringComparison.Ordinal))
			{
				return value;
			}
			return value.Substring(0, value.Length - "(Clone)".Length).TrimEnd();
		}
	}
	internal static class RaceHud
	{
		private enum RacerDisplayState
		{
			Unset = -1,
			Mismatch,
			Syncing,
			Racing,
			Finished,
			Forfeit
		}

		private sealed class RacerRow
		{
			internal GameObject Root;

			internal RectTransform Rect;

			internal Image Background;

			internal TextMeshProUGUI Name;

			internal TextMeshProUGUI Status;

			internal string LastName;

			internal string LastStatus;

			internal string LastNickname;

			internal int LastActorNumber = -1;

			internal bool LastIsLocal;

			internal RacerDisplayState LastDisplayState = RacerDisplayState.Unset;

			internal double LastReportedTime = double.NaN;
		}

		private static readonly List<RacerRow> Rows = new List<RacerRow>();

		private static readonly List<Player> OrderedPlayers = new List<Player>();

		private static Canvas _canvas;

		private static RectTransform _panel;

		private static TextMeshProUGUI _stageText;

		private static TextMeshProUGUI _timerText;

		private static RectTransform _divider;

		private static float _nextRefresh;

		private static float _nextTimerRefresh;

		private static string _lastTimerText;

		private static string _lastStageText;

		private static float _lastScale = -1f;

		private static int _lastStage = -1;

		private static int _lastRound = -1;

		private static int _lastLayoutPlayerCount = -1;

		private static bool _lastLayoutSharedTimer;

		private static int _lastFontRevision = -1;

		private static bool _lastCompactMode;

		private static bool _layoutModeInitialized;

		internal static void Initialize()
		{
			//IL_0032: 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_0064: 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_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_00a5: 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_00cd: 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_00f0: 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_0131: 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_014f: 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_016d: 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_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: 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_027c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_canvas != (Object)null))
			{
				_canvas = PeakVsUi.CreateCanvas("PeakVs Race HUD", 32000, interactive: false);
				_panel = ((Graphic)PeakVsUi.CreateImage(((Component)_canvas).transform, "Standings", PeakVsUi.PanelColor)).rectTransform;
				PeakVsUi.SetRect(_panel, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -16f), new Vector2(530f, 126f));
				PeakVsUi.SetRect(((Graphic)PeakVsUi.CreateImage((Transform)(object)_panel, "Accent", PeakVsUi.AccentColor)).rectTransform, new Vector2(0f, 1f), new Vector2(1f, 1f), new Vector2(0.5f, 1f), Vector2.zero, new Vector2(0f, 4f));
				_stageText = PeakVsUi.CreateText((Transform)(object)_panel, "Biome", 15f, (TextAlignmentOptions)514, PeakVsUi.MutedColor);
				PeakVsUi.SetRect(((TMP_Text)_stageText).rectTransform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -13f), new Vector2(498f, 23f));
				_timerText = PeakVsUi.CreateText((Transform)(object)_panel, "Timer", 31f, (TextAlignmentOptions)514, PeakVsUi.TextColor);
				((TMP_Text)_timerText).fontStyle = (FontStyles)1;
				PeakVsUi.SetRect(((TMP_Text)_timerText).rectTransform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -34f), new Vector2(498f, 42f));
				_divider = ((Graphic)PeakVsUi.CreateImage((Transform)(object)_panel, "Divider", new Color(0.24f, 0.38f, 0.43f, 0.8f))).rectTransform;
				PeakVsUi.SetRect(_divider, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -82f), new Vector2(500f, 1f));
				((Component)_canvas).gameObject.SetActive(false);
			}
		}

		internal static void Tick()
		{
			//IL_0017: 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_0534: Unknown result type (might be due to invalid IL or missing references)
			//IL_0565: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0438: Unknown result type (might be due to invalid IL or missing references)
			//IL_05af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_canvas == (Object)null)
			{
				Initialize();
			}
			if (Input.GetKeyDown(PeakVsPlugin.CompactHudToggleKey.Value))
			{
				PeakVsPlugin.CompactRaceHud.Value = !PeakVsPlugin.CompactRaceHud.Value;
			}
			bool flag = PeakVsPlugin.ShowRaceHud.Value && GameMode.IsActive && PhotonNetwork.CurrentRoom != null;
			if (((Component)_canvas).gameObject.activeSelf != flag)
			{
				((Component)_canvas).gameObject.SetActive(flag);
			}
			if (!flag)
			{
				return;
			}
			float num = Mathf.Clamp(PeakVsPlugin.HudScale.Value, 0.7f, 1.5f);
			if (!Mathf.Approximately(num, _lastScale))
			{
				_lastScale = num;
				((Transform)_panel).localScale = Vector3.one * num;
			}
			bool value = PeakVsPlugin.CompactRaceHud.Value;
			ApplyHudMode(value);
			if (((Component)_timerText).gameObject.activeSelf && Time.unscaledTime >= _nextTimerRefresh)
			{
				_nextTimerRefresh = Time.unscaledTime + 0.1f;
				string text = FormatTime(value ? GetLocalSplitTime() : RaceSession.CurrentStageTime);
				if (text != _lastTimerText)
				{
					_lastTimerText = text;
					((TMP_Text)_timerText).text = text;
				}
			}
			if (Time.unscaledTime < _nextRefresh)
			{
				return;
			}
			_nextRefresh = Time.unscaledTime + 0.2f;
			int fontRevision = PeakVsUi.FontRevision;
			bool flag2 = fontRevision != _lastFontRevision;
			if (flag2)
			{
				_lastFontRevision = fontRevision;
				PeakVsUi.ApplyFont((TMP_Text)(object)_stageText);
				PeakVsUi.ApplyFont((TMP_Text)(object)_timerText);
			}
			if (value)
			{
				UpdateStageText(compact: true);
				for (int i = 0; i < Rows.Count; i++)
				{
					if (Rows[i].Root.activeSelf)
					{
						Rows[i].Root.SetActive(false);
					}
				}
				return;
			}
			OrderedPlayers.Clear();
			foreach (Player value2 in PhotonNetwork.CurrentRoom.Players.Values)
			{
				OrderedPlayers.Add(value2);
			}
			OrderedPlayers.Sort(ComparePlayers);
			EnsureRowCount(OrderedPlayers.Count);
			bool flag3 = true;
			for (int j = 0; j < OrderedPlayers.Count; j++)
			{
				if (ReadResult(OrderedPlayers[j]) != RaceResult.Racing)
				{
					flag3 = false;
					break;
				}
			}
			if (((Component)_timerText).gameObject.activeSelf != flag3)
			{
				((Component)_timerText).gameObject.SetActive(flag3);
			}
			if (flag3)
			{
				string text2 = FormatTime(RaceSession.CurrentStageTime);
				if (text2 != _lastTimerText)
				{
					_lastTimerText = text2;
					((TMP_Text)_timerText).text = text2;
				}
			}
			float num2 = (flag3 ? (-89f) : (-49f));
			UpdateStageText(compact: false);
			for (int k = 0; k < Rows.Count; k++)
			{
				RacerRow racerRow = Rows[k];
				bool flag4 = k < OrderedPlayers.Count;
				if (racerRow.Root.activeSelf != flag4)
				{
					racerRow.Root.SetActive(flag4);
				}
				if (flag2)
				{
					PeakVsUi.ApplyFont((TMP_Text)(object)racerRow.Name);
					PeakVsUi.ApplyFont((TMP_Text)(object)racerRow.Status);
				}
				if (flag4)
				{
					Player val = OrderedPlayers[k];
					bool num3 = racerRow.LastActorNumber != val.ActorNumber;
					string nickName = val.NickName;
					if (num3 || racerRow.LastIsLocal != val.IsLocal || !string.Equals(racerRow.LastNickname, nickName, StringComparison.Ordinal))
					{
						racerRow.LastActorNumber = val.ActorNumber;
						racerRow.LastIsLocal = val.IsLocal;
						racerRow.LastNickname = nickName;
						string text3 = (racerRow.LastName = string.Concat(str1: string.IsNullOrWhiteSpace(nickName) ? $"SCOUT {val.ActorNumber}" : nickName, str0: val.IsLocal ? "›  " : "   "));
						((TMP_Text)racerRow.Name).text = text3;
					}
					Color val2 = (val.IsLocal ? PeakVsUi.AccentColor : PeakVsUi.TextColor);
					if (((Graphic)racerRow.Name).color != val2)
					{
						((Graphic)racerRow.Name).color = val2;
					}
					double time;
					RacerDisplayState racerDisplayState = ReadDisplayState(val, out time);
					if (num3 || racerDisplayState != racerRow.LastDisplayState || time != racerRow.LastReportedTime)
					{
						racerRow.LastDisplayState = racerDisplayState;
						racerRow.LastReportedTime = time;
						Color color;
						string text4 = (racerRow.LastStatus = BuildStatusText(racerDisplayState, time, out color));
						((TMP_Text)racerRow.Status).text = text4;
						((Graphic)racerRow.Status).color = color;
					}
				}
			}
			if (_lastLayoutPlayerCount != OrderedPlayers.Count || _lastLayoutSharedTimer != flag3)
			{
				_lastLayoutPlayerCount = OrderedPlayers.Count;
				_lastLayoutSharedTimer = flag3;
				_divider.anchoredPosition = new Vector2(0f, flag3 ? (-82f) : (-42f));
				for (int l = 0; l < OrderedPlayers.Count; l++)
				{
					Rows[l].Rect.anchoredPosition = new Vector2(0f, num2 - (float)l * 25f);
				}
				_panel.sizeDelta = new Vector2(530f, (flag3 ? 97f : 57f) + (float)OrderedPlayers.Count * 25f);
			}
		}

		internal static void Dispose()
		{
			if ((Object)(object)_canvas != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_canvas).gameObject);
			}
			_canvas = null;
			_panel = null;
			_stageText = null;
			_timerText = null;
			_divider = null;
			_lastTimerText = null;
			_lastStageText = null;
			_lastScale = -1f;
			_lastStage = -1;
			_lastRound = -1;
			_lastLayoutPlayerCount = -1;
			_lastLayoutSharedTimer = false;
			_lastFontRevision = -1;
			_lastCompactMode = false;
			_layoutModeInitialized = false;
			_nextRefresh = 0f;
			_nextTimerRefresh = 0f;
			OrderedPlayers.Clear();
			Rows.Clear();
		}

		private static void ApplyHudMode(bool compact)
		{
			//IL_00b4: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			if (!_layoutModeInitialized || _lastCompactMode != compact)
			{
				_layoutModeInitialized = true;
				_lastCompactMode = compact;
				_lastStage = -1;
				_lastRound = -1;
				_lastLayoutPlayerCount = -1;
				_lastFontRevision = -1;
				_lastTimerText = null;
				_nextRefresh = 0f;
				_nextTimerRefresh = 0f;
				if (((Component)_divider).gameObject.activeSelf == compact)
				{
					((Component)_divider).gameObject.SetActive(!compact);
				}
				if (!((Component)_timerText).gameObject.activeSelf)
				{
					((Component)_timerText).gameObject.SetActive(true);
				}
				float num = (compact ? 332f : 498f);
				((TMP_Text)_stageText).rectTransform.sizeDelta = new Vector2(num, 23f);
				((TMP_Text)_timerText).rectTransform.sizeDelta = new Vector2(num, 42f);
				if (compact)
				{
					_panel.sizeDelta = new Vector2(360f, 80f);
				}
			}
		}

		private static void UpdateStageText(bool compact)
		{
			if (_lastStage != RaceSession.Stage || _lastRound != RaceSession.Round)
			{
				_lastStage = RaceSession.Stage;
				_lastRound = RaceSession.Round;
				string text = (_lastStageText = (compact ? $"PEAK VS  /  {GetStageName()}  /  YOUR SPLIT {Mathf.Max(1, RaceSession.Round + 1)}" : $"PEAK VS  /  {GetStageName()}  /  SPLIT {Mathf.Max(1, RaceSession.Round + 1)}"));
				((TMP_Text)_stageText).text = text;
			}
		}

		private static double GetLocalSplitTime()
		{
			Player localPlayer = PhotonNetwork.LocalPlayer;
			if (localPlayer != null && TryReadInt(localPlayer, "pvs.s", out var value) && value == RaceSession.Stage && TryReadInt(localPlayer, "pvs.n", out var value2) && value2 == RaceSession.Round && TryReadInt(localPlayer, "pvs.r", out var value3) && value3 != 0 && TryReadDouble(localPlayer, "pvs.t", out var value4))
			{
				return value4;
			}
			return RaceSession.CurrentStageTime;
		}

		private static void EnsureRowCount(int count)
		{
			//IL_0030: 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_0035: 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_0064: 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_0082: 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_00a9: 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_00e3: 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_0101: 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_011f: 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_015b: 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_0179: 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_0197: Unknown result type (might be due to invalid IL or missing references)
			while (Rows.Count < count)
			{
				int count2 = Rows.Count;
				Color color = (Color)((count2 % 2 == 0) ? PeakVsUi.RowColor : new Color(0.055f, 0.085f, 0.11f, 0.76f));
				Image val = PeakVsUi.CreateImage((Transform)(object)_panel, $"Racer {count2 + 1}", color);
				PeakVsUi.SetRect(((Graphic)val).rectTransform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -89f - (float)count2 * 25f), new Vector2(500f, 23f));
				TextMeshProUGUI val2 = PeakVsUi.CreateText(((Component)val).transform, "Name", 15f, (TextAlignmentOptions)4097, PeakVsUi.TextColor);
				PeakVsUi.SetRect(((TMP_Text)val2).rectTransform, new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), new Vector2(0f, 0.5f), new Vector2(10f, 0f), new Vector2(280f, 22f));
				TextMeshProUGUI val3 = PeakVsUi.CreateText(((Component)val).transform, "Status", 14f, (TextAlignmentOptions)4100, PeakVsUi.MutedColor);
				PeakVsUi.SetRect(((TMP_Text)val3).rectTransform, new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(1f, 0.5f), new Vector2(-10f, 0f), new Vector2(204f, 22f));
				Rows.Add(new RacerRow
				{
					Root = ((Component)val).gameObject,
					Rect = ((Graphic)val).rectTransform,
					Background = val,
					Name = val2,
					Status = val3
				});
			}
		}

		private static string GetStageName()
		{
			//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_002d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return ((object)MapHandler.GetBiomeForSegment(RaceSession.Stage)/*cast due to .constrained prefix*/).ToString().ToUpperInvariant();
			}
			catch
			{
				return ((object)(Segment)(byte)Mathf.Max(0, RaceSession.Stage)/*cast due to .constrained prefix*/).ToString().ToUpperInvariant();
			}
		}

		private static RacerDisplayState ReadDisplayState(Player player, out double time)
		{
			time = 0.0;
			if (!HasMatchingVersion(player))
			{
				return RacerDisplayState.Mismatch;
			}
			if (!TryReadInt(player, "pvs.s", out var value) || value != RaceSession.Stage || !TryReadInt(player, "pvs.n", out var value2) || value2 != RaceSession.Round || !TryReadInt(player, "pvs.r", out var value3))
			{
				return RacerDisplayState.Syncing;
			}
			RaceResult raceResult = (RaceResult)value3;
			time = (TryReadDouble(player, "pvs.t", out var value4) ? value4 : 0.0);
			return raceResult switch
			{
				RaceResult.Finished => RacerDisplayState.Finished, 
				RaceResult.Forfeit => RacerDisplayState.Forfeit, 
				_ => RacerDisplayState.Racing, 
			};
		}

		private static string BuildStatusText(RacerDisplayState state, double time, out Color color)
		{
			//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_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_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_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_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)
			switch (state)
			{
			case RacerDisplayState.Mismatch:
				color = PeakVsUi.DangerColor;
				return "MOD MISMATCH";
			case RacerDisplayState.Syncing:
				color = PeakVsUi.MutedColor;
				return "SYNCING";
			case RacerDisplayState.Finished:
				color = PeakVsUi.AccentColor;
				return FormatTime(time) + "  FINISHED";
			case RacerDisplayState.Forfeit:
				color = PeakVsUi.WarmColor;
				return FormatTime(time) + "  FF";
			default:
				color = PeakVsUi.TextColor;
				return "RACING";
			}
		}

		private static int ComparePlayers(Player a, Player b)
		{
			RaceResult raceResult = ReadResult(a);
			RaceResult result = ReadResult(b);
			int num = ResultRank(raceResult).CompareTo(ResultRank(result));
			if (num != 0)
			{
				return num;
			}
			if (raceResult == RaceResult.Finished)
			{
				int num2 = ReadTime(a).CompareTo(ReadTime(b));
				if (num2 != 0)
				{
					return num2;
				}
			}
			return a.ActorNumber.CompareTo(b.ActorNumber);
		}

		private static int ResultRank(RaceResult result)
		{
			return result switch
			{
				RaceResult.Finished => 0, 
				RaceResult.Racing => 1, 
				_ => 2, 
			};
		}

		private static RaceResult ReadResult(Player player)
		{
			if (!HasMatchingVersion(player) || !TryReadInt(player, "pvs.s", out var value) || value != RaceSession.Stage || !TryReadInt(player, "pvs.n", out var value2) || value2 != RaceSession.Round || !TryReadInt(player, "pvs.r", out var value3))
			{
				return RaceResult.Racing;
			}
			return (RaceResult)value3;
		}

		private static double ReadTime(Player player)
		{
			if (!TryReadDouble(player, "pvs.t", out var value))
			{
				return double.MaxValue;
			}
			return value;
		}

		private static bool HasMatchingVersion(Player player)
		{
			if (((Dictionary<object, object>)(object)player.CustomProperties).TryGetValue((object)"pvs.v", out object value))
			{
				return Convert.ToString(value) == "0.7.2";
			}
			return false;
		}

		private static bool TryReadInt(Player player, string key, out int value)
		{
			try
			{
				if (((Dictionary<object, object>)(object)player.CustomProperties).TryGetValue((object)key, out object value2))
				{
					value = Convert.ToInt32(value2);
					return true;
				}
			}
			catch
			{
			}
			value = 0;
			return false;
		}

		private static bool TryReadDouble(Player player, string key, out double value)
		{
			try
			{
				if (((Dictionary<object, object>)(object)player.CustomProperties).TryGetValue((object)key, out object value2))
				{
					value = Convert.ToDouble(value2);
					return true;
				}
			}
			catch
			{
			}
			value = 0.0;
			return false;
		}

		internal static string FormatTime(double seconds)
		{
			seconds = Math.Max(0.0, seconds);
			int num = (int)(seconds / 60.0);
			double num2 = seconds - (double)num * 60.0;
			return $"{num:00}:{num2:00.0}";
		}
	}
	internal enum RaceResult
	{
		Racing,
		Finished,
		Forfeit
	}
	internal sealed class PeakVsPresentationState : MonoBehaviour
	{
		internal Renderer[] Renderers;

		internal Renderer[] CharacterRenderers;

		internal BackpackOnBackVisuals[] WornPacks;

		internal Collider[] Colliders;

		internal Light[] Lights;

		internal GloomSafeZone[] SafeZones;

		internal HashSet<Renderer> PresentedRenderers;

		internal HashSet<Collider> IsolatedColliders;

		internal List<Collider> NewColliders;

		internal HashSet<int> IgnoredRacerActors;

		internal float AppliedOpacity = -1f;

		internal bool RivalEffectsDisabled;

		internal int DynamicVersion = -1;
	}
	internal sealed class PeakVsOwnedVisualLifetime : MonoBehaviour
	{
		internal int ViewId;

		internal int OwnerActor;

		private void OnDestroy()
		{
			PrivateLoot.UnregisterOwnedVisual(ViewId, OwnerActor);
		}
	}
	internal sealed class PeakVsOwnedObject : MonoBehaviour
	{
		internal int OwnerActor;
	}
	internal static class RaceSession
	{
		internal const string PlayerVersionKey = "pvs.v";

		internal const string PlayerStageKey = "pvs.s";

		internal const string PlayerRoundKey = "pvs.n";

		internal const string PlayerResultKey = "pvs.r";

		internal const string PlayerTimeKey = "pvs.t";

		internal const string RoomStageKey = "pvs.stage";

		internal const string RoomStartKey = "pvs.start";

		internal const string RoomRoundKey = "pvs.round";

		internal const string RoomMatchedLootKey = "pvs.loot";

		private static readonly Affliction_NoHunger CampSafety = new Affliction_NoHunger
		{
			totalTime = 2.5f
		};

		private static readonly int OpacityId = Shader.PropertyToID("_Opacity");

		private static readonly int BaseColorId = Shader.PropertyToID("_BaseColor");

		private static readonly int ColorId = Shader.PropertyToID("_Color");

		private static readonly int TintId = Shader.PropertyToID("_Tint");

		private static readonly int SurfaceId = Shader.PropertyToID("_Surface");

		private static readonly int ModeId = Shader.PropertyToID("_Mode");

		private static readonly int SrcBlendId = Shader.PropertyToID("_SrcBlend");

		private static readonly int DstBlendId = Shader.PropertyToID("_DstBlend");

		private static readonly int ZWriteId = Shader.PropertyToID("_ZWrite");

		private static readonly MaterialPropertyBlock OpacityProperties = new MaterialPropertyBlock();

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

		private static readonly FieldInfo ItemPropertyBlockField = AccessTools.Field(typeof(Item), "mpb");

		private static int _sceneHandle = int.MinValue;

		private static bool _initialized;

		private static int _stage = -1;

		private static int _round = -1;

		private static bool _reported;

		private static float _nextRoomStateTick;

		private static float _nextLocalResultTick;

		private static float _nextCheckpointTick;

		private static float _nextVisualTick;

		private static float _nextSafetyTick;

		private static Campfire[] _campfires = Array.Empty<Campfire>();

		internal static int Stage => _stage;

		internal static int Round => _round;

		internal static bool SameLuggageLoot
		{
			get
			{
				if (PhotonNetwork.IsMasterClient)
				{
					return PeakVsPlugin.MatchedLuggageLoot.Value;
				}
				if (PhotonNetwork.CurrentRoom != null && ((Dictionary<object, object>)(object)((RoomInfo)PhotonNetwork.CurrentRoom).CustomProperties).TryGetValue((object)"pvs.loot", out object value))
				{
					try
					{
						return Convert.ToBoolean(value);
					}
					catch
					{
					}
				}
				return true;
			}
		}

		internal static double CurrentStageTime
		{
			get
			{
				if (!GameMode.IsActive || PhotonNetwork.CurrentRoom == null)
				{
					return 0.0;
				}
				if (!((Dictionary<object, object>)(object)((RoomInfo)PhotonNetwork.CurrentRoom).CustomProperties).TryGetValue((object)"pvs.start", out object value))
				{
					return 0.0;
				}
				return Math.Max(0.0, PhotonNetwork.Time - Convert.ToDouble(value));
			}
		}

		internal static void Initialize()
		{
			ResetForScene(SceneManagementSafeHandle());
		}

		internal static void ResetForScene(int sceneHandle)
		{
			_sceneHandle = sceneHandle;
			_initialized = false;
			_stage = -1;
			_round = -1;
			_reported = false;
			_nextRoomStateTick = 0f;
			_nextLocalResultTick = 0f;
			_nextCheckpointTick = 0f;
			_nextVisualTick = 0f;
			_nextSafetyTick = 0f;
			_campfires = Array.Empty<Campfire>();
		}

		private static int SceneManagementSafeHandle()
		{
			//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_0008: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				return SceneHandle.op_Implicit(((Scene)(ref activeScene)).handle);
			}
			catch
			{
				return int.MinValue;
			}
		}

		internal static void Tick()
		{
			if (!GameMode.IsActive)
			{
				_initialized = false;
				return;
			}
			PrivateLoot.EnsurePrivateGroup();
			if (!_initialized)
			{
				InitializeRaceScene();
			}
			float unscaledTime = Time.unscaledTime;
			if (unscaledTime >= _nextRoomStateTick)
			{
				_nextRoomStateTick = unscaledTime + 0.1f;
				ReadAndApplyRoomStage();
			}
			if (unscaledTime >= _nextLocalResultTick)
			{
				_nextLocalResultTick = unscaledTime + 0.1f;
				TickLocalResult();
			}
			if (unscaledTime >= _nextSafetyTick)
			{
				_nextSafetyTick = unscaledTime + 0.75f;
				ApplyCampfireSafety();
			}
			if (unscaledTime >= _nextVisualTick)
			{
				_nextVisualTick = unscaledTime + 2f;
				ApplyRacerVisualsAndCollision();
			}
			if (PhotonNetwork.IsMasterClient && unscaledTime >= _nextCheckpointTick)
			{
				_nextCheckpointTick = unscaledTime + 0.5f;
				TryAutoLightCheckpoint();
			}
		}

		private static void InitializeRaceScene()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected I4, but got Unknown
			_initialized = true;
			_campfires = Object.FindObjectsByType<Campfire>((FindObjectsSortMode)0);
			RemoveScoutmasters();
			_stage = (int)MapHandler.CurrentSegmentNumber;
			int num = ReadRoomRound();
			_round = (PhotonNetwork.IsMasterClient ? (num + 1) : Mathf.Max(0, num));
			_reported = false;
			PublishLocalState(RaceResult.Racing, 0.0);
			if (PhotonNetwork.IsMasterClient)
			{
				SetRoomStage(_stage, PhotonNetwork.Time, _round);
				PublishHostOptions();
			}
			PeakVsPlugin.Log.LogInfo((object)$"Race scene {_sceneHandle} initialized at stage {(object)(Segment)(byte)_stage}.");
		}

		private static void ReadAndApplyRoomStage()
		{
			if (PhotonNetwork.CurrentRoom != null && ((Dictionary<object, object>)(object)((RoomInfo)PhotonNetwork.CurrentRoom).CustomProperties).TryGetValue((object)"pvs.stage", out object value))
			{
				int num = Convert.ToInt32(value);
				int num2 = ReadRoomRound();
				if (num != _stage || num2 != _round)
				{
					_stage = num;
					_round = num2;
					_reported = false;
					PublishLocalState(RaceResult.Racing, 0.0);
					PeakVsPlugin.Log.LogInfo((object)$"Starting checkpoint race for {(object)(Segment)(byte)_stage}.");
				}
			}
		}

		private static void TickLocalResult()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || _reported || _stage < 0)
			{
				return;
			}
			if (localCharacter.data.dead)
			{
				ReportForfeit();
				return;
			}
			Campfire val = TryGetCurrentCampfire();
			if ((Object)(object)val != (Object)null)
			{
				Vector3 val2 = localCharacter.Center - ((Component)val).transform.position;
				if (((Vector3)(ref val2)).sqrMagnitude <= val.moraleBoostRadius * val.moraleBoostRadius)
				{
					ReportFinished();
				}
			}
		}

		internal static void ReportForfeit()
		{
			if (GameMode.IsActive && !_reported)
			{
				_reported = true;
				PublishLocalState(RaceResult.Forfeit, CurrentStageTime);
			}
		}

		private static void ReportFinished()
		{
			if (!_reported)
			{
				_reported = true;
				PublishLocalState(RaceResult.Finished, CurrentStageTime);
			}
		}

		private static void PublishLocalState(RaceResult result, double time)
		{
			//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_0022: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_0075: Expected O, but got Unknown
			if (PhotonNetwork.LocalPlayer != null)
			{
				Player localPlayer = PhotonNetwork.LocalPlayer;
				Hashtable val = new Hashtable();
				((Dictionary<object, object>)val).Add((object)"pvs.v", (object)"0.7.2");
				((Dictionary<object, object>)val).Add((object)"pvs.s", (object)_stage);
				((Dictionary<object, object>)val).Add((object)"pvs.n", (object)_round);
				((Dictionary<object, object>)val).Add((object)"pvs.r", (object)(int)result);
				((Dictionary<object, object>)val).Add((object)"pvs.t", (object)time);
				localPlayer.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
			}
		}

		private static void SetRoomStage(int stage, double startTime, int round)
		{
			//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_0023: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_004c: Expected O, but got Unknown
			if (PhotonNetwork.CurrentRoom != null)
			{
				Room currentRoom = PhotonNetwork.CurrentRoom;
				Hashtable val = new Hashtable();
				((Dictionary<object, object>)val).Add((object)"pvs.stage", (object)stage);
				((Dictionary<object, object>)val).Add((object)"pvs.start", (object)startTime);
				((Dictionary<object, object>)val).Add((object)"pvs.round", (object)round);
				currentRoom.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
			}
		}

		private static int ReadRoomRound()
		{
			if (PhotonNetwork.CurrentRoom == null || !((Dictionary<object, object>)(object)((RoomInfo)PhotonNetwork.CurrentRoom).CustomProperties).TryGetValue((object)"pvs.round", out object value))
			{
				return -1;
			}
			try
			{
				return Convert.ToInt32(value);
			}
			catch
			{
				return -1;
			}
		}

		private static void PublishHostOptions()
		{
			//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_0033: Expected O, but got Unknown
			//IL_003a: Expected O, but got Unknown
			if (PhotonNetwork.CurrentRoom != null && PhotonNetwork.IsMasterClient)
			{
				Room currentRoom = PhotonNetwork.CurrentRoom;
				Hashtable val = new Hashtable();
				((Dictionary<object, object>)val).Add((object)"pvs.loot", (object)PeakVsPlugin.MatchedLuggageLoot.Value);
				currentRoom.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
			}
		}

		internal static void HostSetMatchedLuggageLoot(bool enabled)
		{
			if (PhotonNetwork.IsMasterClient)
			{
				PeakVsPlugin.MatchedLuggageLoot.Value = enabled;
				PublishHostOptions();
				PeakVsPlugin.Log.LogInfo((object)("Matched luggage loot " + (enabled ? "enabled" : "disabled") + " by host."));
			}
		}

		private static Campfire TryGetCurrentCampfire()
		{
			try
			{
				Campfire currentCampfire = MapHandler.CurrentCampfire;
				return ((Object)(object)currentCampfire != (Object)null && ((Component)currentCampfire).gameObject.activeInHierarchy) ? currentCampfire : null;
			}
			catch
			{
				return null;
			}
		}

		private static void TryAutoLightCheckpoint()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!PeakVsPlugin.AutoLightCheckpoints.Value)
			{
				return;
			}
			Campfire val = TryGetCurrentCampfire();
			if ((Object)(object)val == (Object)null || (int)val.state != 0)
			{
				return;
			}
			Room currentRoom = PhotonNetwork.CurrentRoom;
			if (currentRoom == null || currentRoom.PlayerCount == 0)
			{
				return;
			}
			foreach (Player value5 in currentRoom.Players.Values)
			{
				if (!((Dictionary<object, object>)(object)value5.CustomProperties).TryGetValue((object)"pvs.v", out object value) || Convert.ToString(value) != "0.7.2" || !((Dictionary<object, object>)(object)value5.CustomProperties).TryGetValue((object)"pvs.s", out object value2) || Convert.ToInt32(value2) != _stage || !((Dictionary<object, object>)(object)value5.CustomProperties).TryGetValue((object)"pvs.n", out object value3) || Convert.ToInt32(value3) != _round || !((Dictionary<object, object>)(object)value5.CustomProperties).TryGetValue((object)"pvs.r", out object value4))
				{
					return;
				}
				RaceResult raceResult = (RaceResult)Convert.ToInt32(value4);
				if (raceResult != RaceResult.Finished && raceResult != RaceResult.Forfeit)
				{
					return;
				}
			}
			PeakVsPlugin.Log.LogInfo((object)"All racers finished or forfeited; lighting checkpoint.");
			val.DebugLight();
		}

		internal static bool HasPendingCheckpoint()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			Campfire val = TryGetCurrentCampfire();
			if ((Object)(object)val != (Object)null)
			{
				return (int)val.state == 0;
			}
			return false;
		}

		internal static void GetLobbyProgress(out int resolved, out int matching, out int total)
		{
			resolved = 0;
			matching = 0;
			Room currentRoom = PhotonNetwork.CurrentRoom;
			total = ((currentRoom != null) ? currentRoom.PlayerCount : 0);
			if (currentRoom == null)
			{
				return;
			}
			foreach (Player value5 in currentRoom.Players.Values)
			{
				try
				{
					if (!((Dictionary<object, object>)(object)value5.CustomProperties).TryGetValue((object)"pvs.v", out object value) || Convert.ToString(value) != "0.7.2" || !((Dictionary<object, object>)(object)value5.CustomProperties).TryGetValue((object)"pvs.s", out object value2) || Convert.ToInt32(value2) != _stage || !((Dictionary<object, object>)(object)value5.CustomProperties).TryGetValue((object)"pvs.n", out object value3) || Convert.ToInt32(value3) != _round)
					{
						continue;
					}
					matching++;
					if (((Dictionary<object, object>)(object)value5.CustomProperties).TryGetValue((object)"pvs.r", out object value4))
					{
						RaceResult raceResult = (RaceResult)Convert.ToInt32(value4);
						if (raceResult == RaceResult.Finished || raceResult == RaceResult.Forfeit)
						{
							resolved++;
						}
					}
				}
				catch
				{
				}
			}
		}

		internal static void HostRestartCurrentSplit()
		{
			if (GameMode.IsActive && PhotonNetwork.IsMasterClient && PhotonNetwork.CurrentRoom != null && _stage >= 0)
			{
				PeakVsPlugin.Log.LogInfo((object)$"Host restarted split for {(object)(Segment)(byte)_stage}.");
				SetRoomStage(_stage, PhotonNetwork.Time, _round + 1);
			}
		}

		internal static void HostForceCheckpoint()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (GameMode.IsActive && PhotonNetwork.IsMasterClient)
			{
				Campfire val = TryGetCurrentCampfire();
				if ((Object)(object)val != (Object)null && (int)val.state == 0)
				{
					PeakVsPlugin.Log.LogWarning((object)"Host forced the current checkpoint.");
					val.DebugLight();
				}
			}
		}

		internal static void OnCampfireLit(Campfire campfire, bool updateSegment)
		{
			//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_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_0037: 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_012a: Expected I4, but got Unknown
			//IL_0059: 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_006a: 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_0077: 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_0088: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (!GameMode.IsActive || !updateSegment)
			{
				return;
			}
			TickLocalResult();
			if (!PhotonNetwork.IsMasterClient)
			{
				return;
			}
			Vector3 val = ((Component)campfire).transform.position + Vector3.up * 1.5f;
			List<Character> allPlayerCharacters = PlayerHandler.GetAllPlayerCharacters();
			for (int i = 0; i < allPlayerCharacters.Count; i++)
			{
				Character val2 = allPlayerCharacters[i];
				if (!((Object)(object)val2 == (Object)null))
				{
					Vector2 val3 = Random.insideUnitCircle * 1.5f;
					Vector3 val4 = val + new Vector3(val3.x, 0f, val3.y);
					if (val2.data.dead || val2.data.fullyPassedOut)
					{
						((MonoBehaviourPun)val2).photonView.RPC("RPCA_ReviveAtPosition", (RpcTarget)0, new object[3] { val4, false, -1 });
					}
					else
					{
						((MonoBehaviourPun)val2).photonView.RPC("WarpPlayerRPC", (RpcTarget)0, new object[2] { val4, true });
					}
				}
			}
			SetRoomStage((int)campfire.advanceToSegment, PhotonNetwork.Time, _round + 1);
		}

		private static void ApplyCampfireSafety()
		{
			//IL_0033: 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_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)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null || localCharacter.data.dead)
			{
				return;
			}
			for (int i = 0; i < _campfires.Length; i++)
			{
				Campfire val = _campfires[i];
				if ((Object)(object)val != (Object)null)
				{
					Vector3 val2 = localCharacter.Center - ((Component)val).transform.position;
					if (((Vector3)(ref val2)).sqrMagnitude <= val.moraleBoostRadius * val.moraleBoostRadius)
					{
						localCharacter.refs.afflictions.AddAffliction((Affliction)(object)CampSafety, false);
						break;
					}
				}
			}
		}

		private static void ApplyRacerVisualsAndCollision()
		{
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null)
			{
				return;
			}
			List<Character> allPlayerCharacters = PlayerHandler.GetAllPlayerCharacters();
			for (int i = 0; i < allPlayerCharacters.Count; i++)
			{
				Character val = allPlayerCharacters[i];
				if ((Object)(object)val == (Object)null || val.isBot)
				{
					continue;
				}
				PeakVsPresentationState peakVsPresentationState;
				if ((Object)(object)val != (Object)(object)localCharacter)
				{
					DisableChickenVisual(val);
					ApplyCharacterOpacity(val, Mathf.Clamp(PeakVsPlugin.RemoteScoutOpacity.Value, 0.15f, 0.9f));
					PeakVsPresentationState presentationState = GetPresentationState((Component)(object)val);
					peakVsPresentationState = presentationState;
					if (peakVsPresentationState.WornPacks == null)
					{
						peakVsPresentationState.WornPacks = ((Component)val).GetComponentsInChildren<BackpackOnBackVisuals>(true);
					}
					for (int j = 0; j < presentationState.WornPacks.Length; j++)
					{
						BackpackOnBackVisuals val2 = presentationState.WornPacks[j];
						if (!((Object)(object)val2 == (Object)null))
						{
							PeakVsPresentationState peakVsPresentationState2 = (peakVsPresentationState = GetPresentationState((Component)(object)val2));
							if (peakVsPresentationState.Renderers == null)
							{
								peakVsPresentationState.Renderers = ((Component)val2).GetComponentsInChildren<Renderer>(true);
							}
							ApplyOpacity(peakVsPresentationState2, peakVsPresentationState2.Renderers, 0.2f);
						}
					}
				}
				PeakVsPresentationState presentationState2 = GetPresentationState((Component)(object)val);
				peakVsPresentationState = presentationState2;
				if (peakVsPresentationState.Colliders == null)
				{
					peakVsPresentationState.Colliders = ((Component)val).GetComponentsInChildren<Collider>(true);
				}
				peakVsPresentationState = presentationState2;
				if (peakVsPresentationState.IgnoredRacerActors == null)
				{
					peakVsPresentationState.IgnoredRacerActors = new HashSet<int>();
				}
				for (int k = i + 1; k < allPlayerCharacters.Count; k++)
				{
					Character val3 = allPlayerCharacters[k];
					if (!((Object)(object)val3 == (Object)null) && !val3.isBot && !((Object)(object)((MonoBehaviourPun)val3).photonView == (Object)null) && presentationState2.IgnoredRacerActors.Add(((Object)val3).GetInstanceID()))
					{
						PeakVsPresentationState presentationState3 = GetPresentationState((Component)(object)val3);
						peakVsPresentationState = presentationState3;
						if (peakVsPresentationState.Colliders == null)
						{
							peakVsPresentationState.Colliders = ((Component)val3).GetComponentsInChildren<Collider>(true);
						}
						IgnoreColliderPairs(presentationState2.Colliders, presentationState3.Colliders);
					}
				}
			}
		}

		internal static void ApplyOwnedVisual(PhotonView view)
		{
			if (!GameMode.IsActive || (Object)(object)view == (Object)null)
			{
				return;
			}
			int ownerActor;
			bool flag = PrivateLoot.TryGetRegisteredOwnedVisualActor(view, out ownerActor);
			if (flag)
			{
				PeakVsOwnedVisualLifetime peakVsOwnedVisualLifetime = ((Component)view).GetComponent<PeakVsOwnedVisualLifetime>();
				if ((Object)(object)peakVsOwnedVisualLifetime == (Object)null)
				{
					peakVsOwnedVisualLifetime = ((Component)view).gameObject.AddComponent<PeakVsOwnedVisualLifetime>();
				}
				peakVsOwnedVisualLifetime.ViewId = view.ViewID;
				peakVsOwnedVisualLifetime.OwnerActor = ownerActor;
			}
			Item component = ((Component)view).GetComponent<Item>();
			if ((Object)(object)component != (Object)null)
			{
				ApplyItemIsolation(component);
			}
			else if (flag)
			{
				ApplyOwnedVisual(view, ownerActor, PlayerHandler.GetAllPlayerCharacters());
			}
		}

		internal static void ApplyOwnedObject(Component root, int ownerActor)
		{
			if (!GameMode.IsActive || (Object)(object)root == (Object)null || ownerActor <= 0)
			{
				return;
			}
			PeakVsPresentationState presentationState = GetPresentationState(root);
			if (PhotonNetwork.LocalPlayer != null && ownerActor != PhotonNetwork.LocalPlayer.ActorNumber)
			{
				PeakVsPresentationState peakVsPresentationState = presentationState;
				if (peakVsPresentationState.Renderers == null)
				{
					peakVsPresentationState.Renderers = root.GetComponentsInChildren<Renderer>(true);
				}
				ApplyOpacity(presentationState, presentationState.Renderers, 0.2f);
			}
			IgnoreOwnedObjectForOtherRacers(ownerActor, presentationState, root, PlayerHandler.GetAllPlayerCharacters());
		}

		internal static void RefreshOwnedVisual(PhotonView view, int dynamicVersion)
		{
			if (GameMode.IsActive && !((Object)(object)view == (Object)null))
			{
				PeakVsPresentationState presentationState = GetPresentationState((Component)(object)view);
				if (presentationState.DynamicVersion != dynamicVersion)
				{
					presentationState.DynamicVersion = dynamicVersion;
					presentationState.Renderers = null;
					presentationState.Colliders = null;
					ApplyOwnedVisual(view);
				}
			}
		}

		private static void ApplyOwnedVisual(PhotonView view, int ownerActor, List<Character> racers)
		{
			PeakVsPresentationState presentationState = GetPresentationState((Component)(object)view);
			if (PhotonNetwork.LocalPlayer != null && ownerActor != PhotonNetwork.LocalPlayer.ActorNumber)
			{
				PeakVsPresentationState peakVsPresentationState = presentationState;
				if (peakVsPresentationState.Renderers == null)
				{
					peakVsPresentationState.Renderers = ((Component)view).GetComponentsInChildren<Renderer>(true);
				}
				ApplyOpacity(presentationState, presentationState.Renderers, 0.2f);
			}
			IgnoreOwnedObjectForOtherRacers(ownerActor, presentationState, (Component)(object)view, racers);
		}

		internal static void ApplyItemIsolation(Item item)
		{
			if (GameMode.IsActive && !((Object)(object)item == (Object)null))
			{
				ApplyItemIsolation(item, PlayerHandler.GetAllPlayerCharacters());
			}
		}

		internal static void ReapplyOwnedItemPresentation(Item item)
		{
			if (GameMode.IsActive && !((Object)(object)item == (Object)null) && !((Object)(object)((MonoBehaviourPun)item).photonView == (Object)null))
			{
				PeakVsPresentationState presentationState = GetPresentationState((Component)(object)item);
				presentationState.Renderers = null;
				presentationState.PresentedRenderers?.Clear();
				ApplyItemIsolation(item);
			}
		}

		private static void ApplyItemIsolation(Item item, List<Character> racers)
		{
			if ((Object)(object)item == (Object)null || (Object)(object)((MonoBehaviourPun)item).photonView == (Object)null || !PrivateLoot.TryGetRegisteredOwnedVisualActor(((MonoBehaviourPun)item).photonView, out var ownerActor))
			{
				return;
			}
			PeakVsPresentationState presentationState = GetPresentationState((Component)(object)item);
			if (PhotonNetwork.LocalPlayer != null && ownerActor != PhotonNetwork.LocalPlayer.ActorNumber)
			{
				item.blockInteraction = true;
				object? obj = ItemPropertyBlockField?.GetValue(item);
				object? obj2 = ((obj is MaterialPropertyBlock) ? obj : null);
				if (obj2 != null)
				{
					((MaterialPropertyBlock)obj2).SetFloat(OpacityId, 0.2f);
				}
				PeakVsPresentationState peakVsPresentationState = presentationState;
				if (peakVsPresentationState.Renderers == null)
				{
					peakVsPresentationState.Renderers = ((Component)item).GetComponentsInChildren<Renderer>(true);
				}
				ApplyOpacity(presentationState, presentationState.Renderers, 0.2f);
				if (!presentationState.RivalEffectsDisabled)
				{
					presentationState.RivalEffectsDisabled = true;
					presentationState.Lights = ((Component)item).GetComponentsInChildren<Light>(true);
					for (int i = 0; i < presentationState.Lights.Length; i++)
					{
						if ((Object)(object)presentationState.Lights[i] != (Object)null)
						{
							((Behaviour)presentationState.Lights[i]).enabled = false;
						}
					}
					presentationState.SafeZones = ((Component)item).GetComponentsInChildren<GloomSafeZone>(true);
					for (int j = 0; j < presentationState.SafeZones.Length; j++)
					{
						if ((Object)(object)presentationState.SafeZones[j] != (Object)null)
						{
							presentationState.SafeZones[j].isLit = false;
						}
					}
				}
			}
			else
			{
				item.blockInteraction = false;
			}
			IgnoreOwnedObjectForOtherRacers(ownerActor, presentationState, (Component)(object)item, racers);
		}

		private static void DisableChickenVisual(Character character)
		{
			CharacterCustomization customization = character.refs.customization;
			if (!((Object)(object)customization == (Object)null) && !((Object)(object)customization.refs == (Object)null))
			{
				if (customization.isCannibalizable)
				{
					customization.BecomeHuman();
				}
				customization.isCannibalizable = false;
				if ((Object)(object)customization.refs.chickenRenderer != (Object)null && ((Component)customization.refs.chickenRenderer).gameObject.activeSelf)
				{
					((Component)customization.refs.chickenRenderer).gameObject.SetActive(false);
				}
				if ((Object)(object)customization.chickenParticle != (Object)null && customization.chickenParticle.isPlaying)
				{
					customization.chickenParticle.Stop(true, (ParticleSystemStopBehavior)0);
				}
			}
		}

		private static void IgnoreOwnedObjectForOtherRacers(int ownerActor, PeakVsPresentationState state, Component root, List<Character> racers)
		{
			PeakVsPresentationState peakVsPresentationState = state;
			if (peakVsPresentationState.Colliders == null)
			{
				peakVsPresentationState.Colliders = root.GetComponentsInChildren<Collider>(true);
			}
			peakVsPresentationState = state;
			if (peakVsPresentationState.IsolatedColliders == null)
			{
				peakVsPresentationState.IsolatedColliders = new HashSet<Collider>();
			}
			peakVsPresentationState = state;
			if (peakVsPresentationState.NewColliders == null)
			{
				peakVsPresentationState.NewColliders = new List<Collider>();
			}
			state.NewColliders.Clear();
			for (int i = 0; i < state.Colliders.Length; i++)
			{
				Collider val = state.Colliders[i];
				if ((Object)(object)val != (Object)null && state.IsolatedColliders.Add(val))
				{
					state.NewColliders.Add(val);
				}
			}
			peakVsPresentationState = state;
			if (peakVsPresentationState.IgnoredRacerActors == null)
			{
				peakVsPresentationState.IgnoredRacerActors = new HashSet<int>();
			}
			for (int j = 0; j < racers.Count; j++)
			{
				Character val2 = racers[j];
				if ((Object)(object)val2 == (Object)null || val2.isBot || (Object)(object)((MonoBehaviourPun)val2).photonView == (Object)null || ((MonoBehaviourPun)val2).photonView.OwnerActorNr == ownerActor)
				{
					continue;
				}
				bool flag = state.IgnoredRacerActors.Add(((Object)val2).GetInstanceID());
				if (flag || state.NewColliders.Count != 0)
				{
					PeakVsPresentationState presentationState = GetPresentationState((Component)(object)val2);
					peakVsPresentationState = presentationState;
					if (peakVsPresentationState.Colliders == null)
					{
						peakVsPresentationState.Colliders = ((Component)val2).GetComponentsInChildren<Collider>(true);
					}
					IList<Collider> first;
					if (!flag)
					{
						IList<Collider> newColliders = state.NewColliders;
						first = newColliders;
					}
					else
					{
						IList<Collider> newColliders = state.Colliders;
						first = newColliders;
					}
					IgnoreColliderPairs(first, presentationState.Colliders);
				}
			}
		}

		private static void IgnoreColliderPairs(IList<Collider> first, IList<Collider> second)
		{
			for (int i = 0; i < first.Count; i++)
			{
				if ((Object)(object)first[i] == (Object)null)
				{
					continue;
				}
				for (int j = 0; j < second.Count; j++)
				{
					if ((Object)(object)second[j] != (Object)null)
					{
						Physics.IgnoreCollision(first[i], second[j], true);
					}
				}
			}
		}

		private static void ApplyCharacterOpacity(Character character, float opacity)
		{
			PeakVsPresentationState presentationState = GetPresentationState((Component)(object)character);
			if (presentationState.CharacterRenderers == null)
			{
				Renderer[] componentsInChildren = ((Component)character).GetComponentsInChildren<Renderer>(true);
				List<Renderer> list = new List<Renderer>(componentsInChildren.Length);
				foreach (Renderer val in componentsInChildren)
				{
					if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).GetComponentInParent<Item>() == (Object)null && (Object)(object)((Component)val).GetComponentInParent<BackpackOnBackVisuals>() == (Object)null)
					{
						list.Add(val);
					}
				}
				presentationState.CharacterRenderers = list.ToArray();
			}
			ApplyOpacity(presentationState, presentationState.CharacterRenderers, opacity);
		}

		private static PeakVsPresentationState GetPresentationState(Component root)
		{
			PeakVsPresentationState peakVsPresentationState = root.GetComponent<PeakVsPresentationState>();
			if ((Object)(object)peakVsPresentationState == (Object)null)
			{
				peakVsPresentationState = root.gameObject.AddComponent<PeakVsPresentationState>();
			}
			return peakVsPresentationState;
		}

		private static void ApplyOpacity(PeakVsPresentationState state, Renderer[] renderers, float opacity)
		{
			if (!Mathf.Approximately(state.AppliedOpacity, opacity))
			{
				state.AppliedOpacity = opacity;
				state.PresentedRenderers?.Clear();
			}
			if (state.PresentedRenderers == null)
			{
				state.PresentedRenderers = new HashSet<Renderer>();
			}
			foreach (Renderer val in renderers)
			{
				if (!((Object)(object)val == (Object)null) && state.PresentedRenderers.Add(val))
				{
					ApplyOpacity(val, opacity);
				}
			}
		}

		private static void ApplyOpacity(Renderer renderer, float opacity)
		{
			//IL_011f: 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)
			SharedMaterials.Clear();
			renderer.GetSharedMaterials(SharedMaterials);
			bool flag = false;
			bool flag2 = true;
			for (int i = 0; i < SharedMaterials.Count; i++)
			{
				Material val = SharedMaterials[i];
				if (!((Object)(object)val == (Object)null))
				{
					flag = true;
					if (!val.HasProperty(OpacityId))
					{
						flag2 = false;
						break;
					}
				}
			}
			if (flag && flag2)
			{
				OpacityProperties.Clear();
				renderer.GetPropertyBlock(OpacityProperties);
				OpacityProperties.SetFloat(OpacityId, opacity);
				renderer.SetPropertyBlock(OpacityProperties);
				return;
			}
			Material[] materials = renderer.materials;
			foreach (Material val2 in materials)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				if (val2.HasProperty(OpacityId))
				{
					val2.SetFloat(OpacityId, opacity);
					continue;
				}
				int num = (val2.HasProperty(BaseColorId) ? BaseColorId : (val2.HasProperty(ColorId) ? ColorId : (val2.HasProperty(TintId) ? TintId : (-1))));
				if (num >= 0)
				{
					Color color = val2.GetColor(num);
					color.a = opacity;
					val2.SetColor(num, color);
					val2.SetOverrideTag("RenderType", "Transparent");
					if (val2.HasProperty(SurfaceId))
					{
						val2.SetFloat(SurfaceId, 1f);
						val2.EnableKeyword("_SURFACE_TYPE_TRANSPARENT");
					}
					if (val2.HasProperty(ModeId))
					{
						val2.SetFloat(ModeId, 3f);
					}
					if (val2.HasProperty(SrcBlendId))
					{
						val2.SetFloat(SrcBlendId, 5f);
					}
					if (val2.HasProperty(DstBlendId))
					{
						val2.SetFloat(DstBlendId, 10f);
					}
					if (val2.HasProperty(ZWriteId))
					{
						val2.SetFloat(ZWriteId, 0f);
					}
					val2.DisableKeyword("_ALPHATEST_ON");
					val2.EnableKeyword("_ALPHABLEND_ON");
					val2.renderQueue = 3000;
				}
			}
		}

		private static void RemoveScoutmasters()
		{
			Scoutmaster[] array = Object.FindObjectsByType<Scoutmaster>((FindObjectsSortMode)0);
			foreach (Scoutmaster val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					PhotonView component = ((Component)val).GetComponent<PhotonView>();
					if (PhotonNetwork.IsMasterClient && (Object)(object)component != (Object)null && component.IsRoomView)
					{
						PhotonNetwork.Destroy(component);
					}
					else
					{
						((Component)val).gameObject.SetActive(false);
					}
				}
			}
		}
	}
}