using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BombRushMP.BunchOfEmotes;
using BombRushMP.Common;
using BombRushMP.Common.Networking;
using BombRushMP.Common.Packets;
using BombRushMP.CrewBoom;
using BombRushMP.MapStation;
using BombRushMP.Mono;
using BombRushMP.Mono.Runtime;
using BombRushMP.NetRadio;
using BombRushMP.NetworkInterfaceProvider;
using BombRushMP.Plugin;
using BombRushMP.Plugin.Gamemodes;
using BombRushMP.Plugin.LocalServer;
using BombRushMP.Plugin.OfflineInterface;
using BombRushMP.Plugin.Patches;
using BombRushMP.Plugin.Phone;
using BombRushMP.PluginCommon;
using BombRushMP.Server;
using CommonAPI;
using CommonAPI.Phone;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Reptile;
using Reptile.Phone;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Playables;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.TextCore;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("BombRushMP.Plugin")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("My first plugin")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1+c7b1b5d46d095617c81eaf82b70b65c1d0c82a16")]
[assembly: AssemblyProduct("BombRushMP.Plugin")]
[assembly: AssemblyTitle("BombRushMP.Plugin")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class AppJoinLobbyDebug : CustomApp
{
	public override bool Available => false;

	public static void Initialize()
	{
		PhoneAPI.RegisterApp<AppJoinLobbyDebug>("debug join lobby", (Sprite)null);
	}

	public override void OnAppInit()
	{
		((CustomApp)this).OnAppInit();
		((CustomApp)this).CreateIconlessTitleBar("Lobbies", 80f);
		base.ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
	}

	public override void OnAppEnable()
	{
		((App)this).OnAppEnable();
		PopulateButtons();
	}

	private void PopulateButtons()
	{
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		base.ScrollView.RemoveAllButtons();
		ClientController clientController = ClientController.Instance;
		foreach (KeyValuePair<uint, Lobby> lobby in clientController.ClientLobbyManager.Lobbies)
		{
			MPPlayer mPPlayer = clientController.Players[lobby.Value.LobbyState.HostId];
			SimplePhoneButton val = PhoneUIUtility.CreateSimpleButton($"[{lobby.Value.LobbyState.Players.Count}] {GamemodeFactory.GetGamemodeName(lobby.Value.LobbyState.Gamemode)} - {MPUtility.GetPlayerDisplayName(mPPlayer.ClientState)}");
			((PhoneButton)val).OnConfirm = (Action)Delegate.Combine(((PhoneButton)val).OnConfirm, (Action)delegate
			{
				clientController.ClientLobbyManager.JoinLobby(lobby.Key);
			});
			base.ScrollView.AddButton((PhoneButton)(object)val);
		}
	}
}
public class AppMultiplayer : CustomApp
{
	private PhoneButton _createLobbyButton;

	private PhoneButton _lobbyButton;

	private bool _waitingForLobbyCreateResponse;

	public static void Initialize()
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Expected O, but got Unknown
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Expected O, but got Unknown
		byte[] array = File.ReadAllBytes(Path.Combine(MPSettings.Instance.Directory, "acn_icon.png"));
		Texture2D val = new Texture2D(1, 1);
		ImageConversion.LoadImage(val, array);
		((Texture)val).wrapMode = (TextureWrapMode)1;
		Sprite val2 = TextureUtility.CreateSpriteFromTexture(val);
		PhoneAPI.RegisterApp<AppMultiplayer>("multiplayer", val2);
	}

	public override void OnAppInit()
	{
		((CustomApp)this).OnAppInit();
		((CustomApp)this).CreateIconlessTitleBar("Multiplayer", 70f);
		base.ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
		PopulateButtons();
	}

	public override void OnAppUpdate()
	{
		((App)this).OnAppUpdate();
		ClientController instance = ClientController.Instance;
		if (!instance.Connected)
		{
			_waitingForLobbyCreateResponse = false;
			ClientController.PacketReceived = (Action<Packets, Packet>)Delegate.Remove(ClientController.PacketReceived, new Action<Packets, Packet>(OnPacketReceived_LobbyCreation));
		}
		if (instance.ClientLobbyManager.CurrentLobby != null)
		{
			if ((Object)(object)_lobbyButton == (Object)null)
			{
				MakeLobbyButton();
			}
			if ((Object)(object)_createLobbyButton != (Object)null)
			{
				base.ScrollView.RemoveButton(_createLobbyButton);
				_createLobbyButton = null;
			}
		}
		else
		{
			if ((Object)(object)_createLobbyButton == (Object)null)
			{
				MakeCreateLobbyButton();
			}
			if ((Object)(object)_lobbyButton != (Object)null)
			{
				base.ScrollView.RemoveButton(_lobbyButton);
				_lobbyButton = null;
			}
		}
	}

	private void MakeCreateLobbyButton()
	{
		ClientLobbyManager lobbyManager = ClientController.Instance.ClientLobbyManager;
		_createLobbyButton = (PhoneButton)(object)PhoneUIUtility.CreateSimpleButton("Create Lobby");
		PhoneButton createLobbyButton = _createLobbyButton;
		createLobbyButton.OnConfirm = (Action)Delegate.Combine(createLobbyButton.OnConfirm, (Action)delegate
		{
			if (!_waitingForLobbyCreateResponse)
			{
				GamemodeSettings gamemodeSettings = GamemodeFactory.GetGamemodeSettings((GamemodeIDs)0);
				SavedGamemodeSettings savedSettings = MPSaveData.Instance.GetSavedSettings((GamemodeIDs)0);
				if (savedSettings != null)
				{
					gamemodeSettings.ApplySaved(savedSettings);
				}
				lobbyManager.CreateLobby((GamemodeIDs)0, gamemodeSettings);
				_waitingForLobbyCreateResponse = true;
				ClientController.PacketReceived = (Action<Packets, Packet>)Delegate.Combine(ClientController.PacketReceived, new Action<Packets, Packet>(OnPacketReceived_LobbyCreation));
			}
		});
		base.ScrollView.InsertButton(0, _createLobbyButton);
	}

	private void OnPacketReceived_LobbyCreation(Packets packetId, Packet packet)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Invalid comparison between Unknown and I4
		if ((int)packetId == 14)
		{
			_waitingForLobbyCreateResponse = false;
			ClientController.PacketReceived = (Action<Packets, Packet>)Delegate.Remove(ClientController.PacketReceived, new Action<Packets, Packet>(OnPacketReceived_LobbyCreation));
			((App)this).MyPhone.OpenApp(typeof(AppMultiplayerCurrentLobby));
		}
	}

	private void MakeLobbyButton()
	{
		_lobbyButton = (PhoneButton)(object)PhoneUIUtility.CreateSimpleButton("Lobby");
		PhoneButton lobbyButton = _lobbyButton;
		lobbyButton.OnConfirm = (Action)Delegate.Combine(lobbyButton.OnConfirm, (Action)delegate
		{
			((App)this).MyPhone.OpenApp(typeof(AppMultiplayerCurrentLobby));
		});
		base.ScrollView.InsertButton(0, _lobbyButton);
	}

	private void PopulateButtons()
	{
		base.ScrollView.RemoveAllButtons();
		SimplePhoneButton val = PhoneUIUtility.CreateSimpleButton("Invites");
		SimplePhoneButton obj = val;
		((PhoneButton)obj).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj).OnConfirm, (Action)delegate
		{
			((App)this).MyPhone.OpenApp(typeof(AppMultiplayerInvites));
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Join Public Lobby");
		SimplePhoneButton obj2 = val;
		((PhoneButton)obj2).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj2).OnConfirm, (Action)delegate
		{
			((App)this).MyPhone.OpenApp(typeof(AppMultiplayerPublicLobbies));
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Stages");
		SimplePhoneButton obj3 = val;
		((PhoneButton)obj3).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj3).OnConfirm, (Action)delegate
		{
			if (MapStationSupport.Stages.Count > 0)
			{
				((App)this).MyPhone.OpenApp(typeof(AppMultiplayerStages));
			}
			else
			{
				((App)this).MyPhone.OpenApp(typeof(AppMultiplayerBaseStages));
			}
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Spectate");
		SimplePhoneButton obj4 = val;
		((PhoneButton)obj4).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj4).OnConfirm, (Action)delegate
		{
			SpectatorController.StartSpectating(forced: false);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Go AFK");
		SimplePhoneButton obj5 = val;
		((PhoneButton)obj5).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj5).OnConfirm, (Action)delegate
		{
			PlayerComponent.Get(((App)this).MyPhone.player).ForceAFK();
			((App)this).MyPhone.TurnOff(true);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Stop AFK");
		SimplePhoneButton obj6 = val;
		((PhoneButton)obj6).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj6).OnConfirm, (Action)delegate
		{
			PlayerComponent.Get(((App)this).MyPhone.player).StopAFK();
			((App)this).MyPhone.TurnOff(true);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Movestyle");
		SimplePhoneButton obj7 = val;
		((PhoneButton)obj7).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj7).OnConfirm, (Action)delegate
		{
			((App)this).MyPhone.OpenApp(typeof(MoveStylePickerApp));
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Stats");
		SimplePhoneButton obj8 = val;
		((PhoneButton)obj8).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj8).OnConfirm, (Action)delegate
		{
			SpectatorController instance = SpectatorController.Instance;
			if (!((Object)(object)instance != (Object)null) || !instance.Forced)
			{
				StatsUI instance2 = StatsUI.Instance;
				if (!instance2.Displaying)
				{
					((App)this).MyPhone.TurnOff(false);
					instance2.Activate();
				}
			}
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
	}
}
public class AppMultiplayerBaseStages : StageListApp
{
	private static bool LastSortedByPlayerCount = false;

	private static Dictionary<string, Stage> StageMap = new Dictionary<string, Stage>
	{
		{
			"Hideout",
			(Stage)5
		},
		{
			"Versum Hill",
			(Stage)4
		},
		{
			"Millenium Square",
			(Stage)11
		},
		{
			"Brink Terminal",
			(Stage)12
		},
		{
			"Millenium Mall",
			(Stage)6
		},
		{
			"Mataan",
			(Stage)7
		},
		{
			"Pyramid Island",
			(Stage)9
		},
		{
			"Police Station",
			(Stage)8
		}
	};

	public override bool Available => false;

	public static void Initialize()
	{
		PhoneAPI.RegisterApp<AppMultiplayerBaseStages>("base stages", (Sprite)null);
	}

	public override void OnAppInit()
	{
		((CustomApp)this).OnAppInit();
		((CustomApp)this).CreateIconlessTitleBar("Base Stages", 70f);
		((CustomApp)this).ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
	}

	public override void OnAppEnable()
	{
		((App)this).OnAppEnable();
		PopulateButtons(LastSortedByPlayerCount);
	}

	private void PopulateButtons(bool sortByPlayerCount = false)
	{
		//IL_0106: Unknown result type (might be due to invalid IL or missing references)
		LastSortedByPlayerCount = sortByPlayerCount;
		((CustomApp)this).ScrollView.RemoveAllButtons();
		SimplePhoneButton val = PhoneUIUtility.CreateSimpleButton("Sort: Player Count");
		SimplePhoneButton obj = val;
		((PhoneButton)obj).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj).OnConfirm, (Action)delegate
		{
			PopulateButtons(sortByPlayerCount: true);
		});
		((CustomApp)this).ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Sort: Default");
		SimplePhoneButton obj2 = val;
		((PhoneButton)obj2).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj2).OnConfirm, (Action)delegate
		{
			PopulateButtons();
		});
		((CustomApp)this).ScrollView.AddButton((PhoneButton)(object)val);
		Dictionary<string, Stage> dictionary = new Dictionary<string, Stage>(StageMap);
		if (sortByPlayerCount)
		{
			dictionary = StageMap.OrderByDescending((KeyValuePair<string, Stage> x) => base.ClientController.GetPlayerCountForStage(x.Value)).ToDictionary((KeyValuePair<string, Stage> x) => x.Key, (KeyValuePair<string, Stage> x) => x.Value);
		}
		foreach (KeyValuePair<string, Stage> item in dictionary)
		{
			CreateStageButton(item.Key, item.Value);
		}
	}
}
public class AppMultiplayerCustomStages : StageListApp
{
	private static bool LastSortedByPlayerCount;

	public override bool Available => false;

	public static void Initialize()
	{
		PhoneAPI.RegisterApp<AppMultiplayerCustomStages>("custom stages", (Sprite)null);
	}

	public override void OnAppInit()
	{
		((CustomApp)this).OnAppInit();
		((CustomApp)this).CreateIconlessTitleBar("Custom Stages", 70f);
		((CustomApp)this).ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
		PopulateButtons(LastSortedByPlayerCount);
	}

	private void PopulateButtons(bool sortByPlayerCount = false)
	{
		LastSortedByPlayerCount = sortByPlayerCount;
		((CustomApp)this).ScrollView.RemoveAllButtons();
		SimplePhoneButton val = PhoneUIUtility.CreateSimpleButton("Sort: Player Count");
		SimplePhoneButton obj = val;
		((PhoneButton)obj).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj).OnConfirm, (Action)delegate
		{
			PopulateButtons(sortByPlayerCount: true);
		});
		((CustomApp)this).ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Sort: Alphabetically");
		SimplePhoneButton obj2 = val;
		((PhoneButton)obj2).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj2).OnConfirm, (Action)delegate
		{
			PopulateButtons();
		});
		((CustomApp)this).ScrollView.AddButton((PhoneButton)(object)val);
		List<MPStage> source = new List<MPStage>(MapStationSupport.Stages);
		source = source.OrderBy((MPStage x) => x.DisplayName).ToList();
		if (sortByPlayerCount)
		{
			source = source.OrderByDescending((MPStage x) => base.ClientController.GetPlayerCountForStage((Stage)x.Id)).ToList();
		}
		foreach (MPStage item in source)
		{
			CreateStageButton(item.DisplayName, (Stage)item.Id);
		}
	}
}
public class AppMultiplayerDebug : CustomApp
{
	public override bool Available => false;

	public static void Initialize()
	{
		PhoneAPI.RegisterApp<AppMultiplayerDebug>("multiplayer debug", (Sprite)null);
	}

	public override void OnAppInit()
	{
		((CustomApp)this).OnAppInit();
		((CustomApp)this).CreateIconlessTitleBar("Debug", 80f);
		base.ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
		PopulateButtons();
	}

	private void PopulateButtons()
	{
		base.ScrollView.RemoveAllButtons();
		SimplePhoneButton val = PhoneUIUtility.CreateSimpleButton("Join Lobby");
		SimplePhoneButton obj = val;
		((PhoneButton)obj).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj).OnConfirm, (Action)delegate
		{
			((App)this).MyPhone.OpenApp(typeof(AppJoinLobbyDebug));
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("LowTierGod Skin");
		SimplePhoneButton obj2 = val;
		((PhoneButton)obj2).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj2).OnConfirm, (Action)delegate
		{
			Player currentPlayer8 = WorldHandler.instance.GetCurrentPlayer();
			SpecialSkinManager.Instance.ApplySpecialSkinToPlayer(currentPlayer8, (SpecialSkins)9);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Sean Kingston Skin");
		SimplePhoneButton obj3 = val;
		((PhoneButton)obj3).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj3).OnConfirm, (Action)delegate
		{
			Player currentPlayer7 = WorldHandler.instance.GetCurrentPlayer();
			SpecialSkinManager.Instance.ApplySpecialSkinToPlayer(currentPlayer7, (SpecialSkins)3);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Steve Skin");
		SimplePhoneButton obj4 = val;
		((PhoneButton)obj4).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj4).OnConfirm, (Action)delegate
		{
			Player currentPlayer6 = WorldHandler.instance.GetCurrentPlayer();
			SpecialSkinManager.Instance.ApplySpecialSkinToPlayer(currentPlayer6, (SpecialSkins)6);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Minecraft Skin");
		SimplePhoneButton obj5 = val;
		((PhoneButton)obj5).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj5).OnConfirm, (Action)delegate
		{
			Player currentPlayer5 = WorldHandler.instance.GetCurrentPlayer();
			SpecialSkinManager.Instance.ApplySpecialSkinToPlayer(currentPlayer5, (SpecialSkins)8);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Red Minecraft Skin");
		SimplePhoneButton obj6 = val;
		((PhoneButton)obj6).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj6).OnConfirm, (Action)delegate
		{
			Player currentPlayer4 = WorldHandler.instance.GetCurrentPlayer();
			SpecialSkinManager.Instance.ApplySpecialSkinToPlayer(currentPlayer4, (SpecialSkins)7);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Cop Skin Test");
		SimplePhoneButton obj7 = val;
		((PhoneButton)obj7).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj7).OnConfirm, (Action)delegate
		{
			Player currentPlayer3 = WorldHandler.instance.GetCurrentPlayer();
			if (Random.Range(0, 2) == 0)
			{
				SpecialSkinManager.Instance.ApplySpecialSkinToPlayer(currentPlayer3, (SpecialSkins)0);
			}
			else
			{
				SpecialSkinManager.Instance.ApplySpecialSkinToPlayer(currentPlayer3, (SpecialSkins)1);
			}
			SpecialSkinManager.Instance.ApplyRandomVariantToPlayer(currentPlayer3);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Remove Skin");
		SimplePhoneButton obj8 = val;
		((PhoneButton)obj8).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj8).OnConfirm, (Action)delegate
		{
			Player currentPlayer2 = WorldHandler.instance.GetCurrentPlayer();
			SpecialSkinManager.Instance.RemoveSpecialSkinFromPlayer(currentPlayer2);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Enable ProSkater Mode");
		SimplePhoneButton obj9 = val;
		((PhoneButton)obj9).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj9).OnConfirm, (Action)delegate
		{
			ProSkaterPlayer.Set(WorldHandler.instance.GetCurrentPlayer(), set: true);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Disable ProSkater Mode");
		SimplePhoneButton obj10 = val;
		((PhoneButton)obj10).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj10).OnConfirm, (Action)delegate
		{
			ProSkaterPlayer.Set(WorldHandler.instance.GetCurrentPlayer(), set: false);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Enable Prop Hunt Mode");
		SimplePhoneButton obj11 = val;
		((PhoneButton)obj11).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj11).OnConfirm, (Action)delegate
		{
			PropDisguiseController.Instance.FreezeProps();
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Disable Prop Hunt Mode");
		SimplePhoneButton obj12 = val;
		((PhoneButton)obj12).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj12).OnConfirm, (Action)delegate
		{
			PropDisguiseController.Instance.UnfreezeProps();
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Apply Nearest Disguise");
		SimplePhoneButton obj13 = val;
		((PhoneButton)obj13).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj13).OnConfirm, (Action)delegate
		{
			//IL_0037: 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)
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			PropDisguiseController instance = PropDisguiseController.Instance;
			float num = float.PositiveInfinity;
			int disguiseId = 0;
			bool flag = false;
			foreach (KeyValuePair<int, GameObject> item in instance.PropByIndex)
			{
				float num2 = Vector3.Distance(((Component)currentPlayer).transform.position, item.Value.transform.position);
				if (!flag)
				{
					num = num2;
					disguiseId = item.Key;
					flag = true;
				}
				else if (num2 < num)
				{
					num = num2;
					disguiseId = item.Key;
				}
			}
			if (flag)
			{
				PlayerComponent.Get(currentPlayer).ApplyPropDisguise(disguiseId);
			}
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Remove Disguise");
		SimplePhoneButton obj14 = val;
		((PhoneButton)obj14).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj14).OnConfirm, (Action)delegate
		{
			PlayerComponent.GetLocal().RemovePropDisguise();
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Kill Yourself");
		SimplePhoneButton obj15 = val;
		((PhoneButton)obj15).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj15).OnConfirm, (Action)delegate
		{
			WorldHandler.instance.GetCurrentPlayer().ChangeHP(99999);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Test Map Ping");
		SimplePhoneButton obj16 = val;
		((PhoneButton)obj16).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj16).OnConfirm, (Action)delegate
		{
			MPUtility.PingInMap(((Component)WorldHandler.instance.GetCurrentPlayer()).gameObject, 2f);
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
	}
}
public class AppMultiplayerPublicLobbies : CustomApp
{
	public override bool Available => false;

	public static void Initialize()
	{
		PhoneAPI.RegisterApp<AppMultiplayerPublicLobbies>("public lobbies", (Sprite)null);
	}

	public override void OnAppInit()
	{
		((CustomApp)this).OnAppInit();
		((CustomApp)this).CreateIconlessTitleBar("Lobbies", 80f);
		base.ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
	}

	public override void OnAppEnable()
	{
		((App)this).OnAppEnable();
		PopulateButtons();
	}

	private void PopulateButtons()
	{
		base.ScrollView.RemoveAllButtons();
		ClientController clientController = ClientController.Instance;
		ClientLobbyManager clientLobbyManager = clientController.ClientLobbyManager;
		foreach (KeyValuePair<uint, Lobby> lobby in clientLobbyManager.Lobbies.OrderBy((KeyValuePair<uint, Lobby> p) => p.Value.InGame ? 1 : 0))
		{
			if ((clientLobbyManager.CurrentLobby != null && clientLobbyManager.CurrentLobby.LobbyState.Id == lobby.Key) || !lobby.Value.LobbyState.Challenge)
			{
				continue;
			}
			string text = $"({lobby.Value.LobbyState.Players.Count}) {clientLobbyManager.GetLobbyName(lobby.Key)} - {MPUtility.GetPlayerDisplayName(clientController.Players[lobby.Value.LobbyState.HostId].ClientState)}";
			if (lobby.Value.LobbyState.InGame)
			{
				text += " (In Progress)";
			}
			_ = clientController.Players[lobby.Value.LobbyState.HostId];
			SimplePhoneButton val = PhoneUIUtility.CreateSimpleButton(text);
			((TMP_Text)val.Label).spriteAsset = MPAssets.Instance.Sprites;
			((PhoneButton)val).OnConfirm = (Action)Delegate.Combine(((PhoneButton)val).OnConfirm, (Action)delegate
			{
				if (lobby.Value.LobbyState.Challenge)
				{
					if (lobby.Value.LobbyState.InGame)
					{
						clientController.ClientLobbyManager.QueueJoinLobby(lobby.Key);
						ChatUI.Instance.AddMessage("<color=yellow>Lobby is currently in-game. You will join when the game ends.</color>");
					}
					else
					{
						clientController.ClientLobbyManager.JoinLobby(lobby.Key);
					}
				}
			});
			base.ScrollView.AddButton((PhoneButton)(object)val);
		}
	}
}
public class AppMultiplayerStages : CustomApp
{
	public override bool Available => false;

	public static void Initialize()
	{
		PhoneAPI.RegisterApp<AppMultiplayerStages>("stages", (Sprite)null);
	}

	public override void OnAppInit()
	{
		((CustomApp)this).OnAppInit();
		((CustomApp)this).CreateIconlessTitleBar("Stages", 80f);
		base.ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
		PopulateButtons();
	}

	private void PopulateButtons()
	{
		base.ScrollView.RemoveAllButtons();
		SimplePhoneButton val = PhoneUIUtility.CreateSimpleButton("Base Stages");
		SimplePhoneButton obj = val;
		((PhoneButton)obj).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj).OnConfirm, (Action)delegate
		{
			((App)this).MyPhone.OpenApp(typeof(AppMultiplayerBaseStages));
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
		val = PhoneUIUtility.CreateSimpleButton("Custom Stages");
		SimplePhoneButton obj2 = val;
		((PhoneButton)obj2).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj2).OnConfirm, (Action)delegate
		{
			((App)this).MyPhone.OpenApp(typeof(AppMultiplayerCustomStages));
		});
		base.ScrollView.AddButton((PhoneButton)(object)val);
	}
}
public abstract class StageListApp : CustomApp
{
	protected ClientController ClientController => ClientController.Instance;

	protected SimplePhoneButton CreateStageButton(string label, Stage stage)
	{
		//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_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)
		SimplePhoneButton val = PhoneUIUtility.CreateSimpleButton("(0) " + label);
		((PhoneButton)val).OnConfirm = (Action)Delegate.Combine(((PhoneButton)val).OnConfirm, (Action)delegate
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Core.Instance.BaseModule.StageManager.ExitCurrentStage(stage, (Stage)(-1));
		});
		StageButton stageButton = ((Component)val).gameObject.AddComponent<StageButton>();
		stageButton.Stage = stage;
		stageButton.StageName = label;
		base.ScrollView.AddButton((PhoneButton)(object)val);
		return val;
	}
}
namespace BombRushMP.Plugin
{
	public static class AprilClient
	{
		public const string AprilTag = "april";

		public static int[] AprilBadges = new int[18]
		{
			38, 47, 34, 35, 25, 2, 55, 56, 57, 58,
			59, 60, 61, 62, 54, 64, 65, 66
		};

		public static int GetBadgeForName(string name)
		{
			Random random = new Random(name.GetHashCode());
			return AprilBadges[random.Next(AprilBadges.Length)];
		}

		public static bool GetAprilEventEnabled()
		{
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			if (instance.ServerState == null)
			{
				return false;
			}
			return instance.ServerState.Tags.Contains("april");
		}
	}
	public static class AudioLibraryUtils
	{
		public static AudioLibrary CreateFromSpecialSkin(SpecialSkinDefinition definition)
		{
			//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_000b: Expected O, but got Unknown
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_0127: Expected O, but got Unknown
			AudioLibrary val = new AudioLibrary();
			AudioCollection val2 = new AudioCollection();
			AudioCollection val3 = new AudioCollection();
			AudioCollection val4 = new AudioCollection();
			AudioCollection val5 = new AudioCollection();
			AudioCollection val6 = new AudioCollection();
			AudioCollection val7 = new AudioCollection();
			AudioCollection val8 = new AudioCollection();
			val2.Clips.AddRange(definition.Jump);
			val3.Clips.AddRange(definition.GetHit);
			val4.Clips.AddRange(definition.Die);
			val5.Clips.AddRange(definition.DieFall);
			val6.Clips.AddRange(definition.Combo);
			val7.Clips.AddRange(definition.BoostTrick);
			val8.Clips.AddRange(definition.Talk);
			val.Collections[(AudioClipID)489] = val2;
			val.Collections[(AudioClipID)488] = val3;
			val.Collections[(AudioClipID)484] = val4;
			val.Collections[(AudioClipID)485] = val5;
			val.Collections[(AudioClipID)487] = val6;
			val.Collections[(AudioClipID)498] = val7;
			val.Collections[(AudioClipID)486] = val8;
			return val;
		}
	}
	public class BadgeMap
	{
		private TMP_SpriteAsset _spriteAsset;

		public BadgeMap(TMP_SpriteAsset spriteAsset)
		{
			_spriteAsset = spriteAsset;
		}

		public void ParseFromDirectory(string path, int padding)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: 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_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Expected O, but got Unknown
			string[] files = Directory.GetFiles(path, "*.png");
			List<Texture2D> list = new List<Texture2D>();
			List<int> list2 = new List<int>();
			string[] array = files;
			foreach (string path2 in array)
			{
				Texture2D val = new Texture2D(2, 2);
				ImageConversion.LoadImage(val, File.ReadAllBytes(path2), false);
				int item = int.Parse(Path.GetFileNameWithoutExtension(path2));
				list.Add(val);
				list2.Add(item);
			}
			Texture2D val2 = new Texture2D(2, 2);
			Rect[] array2 = val2.PackTextures(list.ToArray(), padding);
			((Texture)val2).filterMode = (FilterMode)(MPSettings.Instance.SmoothSprites ? 1 : 0);
			((Texture)val2).wrapMode = (TextureWrapMode)1;
			_spriteAsset.spriteSheet = (Texture)(object)val2;
			int num = list2.Max() + 1;
			TMP_SpriteGlyph[] collection = (TMP_SpriteGlyph[])(object)new TMP_SpriteGlyph[num];
			TMP_SpriteCharacter[] collection2 = (TMP_SpriteCharacter[])(object)new TMP_SpriteCharacter[num];
			_spriteAsset.spriteGlyphTable.Clear();
			_spriteAsset.spriteCharacterTable.Clear();
			_spriteAsset.spriteGlyphTable.AddRange(collection);
			_spriteAsset.spriteCharacterTable.AddRange(collection2);
			for (int j = 0; j < list.Count; j++)
			{
				TMP_SpriteGlyph val3 = new TMP_SpriteGlyph
				{
					index = (uint)list2[j],
					glyphRect = new GlyphRect((int)(((Rect)(ref array2[j])).x * (float)((Texture)val2).width), (int)(((Rect)(ref array2[j])).y * (float)((Texture)val2).height), (int)(((Rect)(ref array2[j])).width * (float)((Texture)val2).width), (int)(((Rect)(ref array2[j])).height * (float)((Texture)val2).height)),
					metrics = new GlyphMetrics(((Rect)(ref array2[j])).width * (float)((Texture)val2).width, ((Rect)(ref array2[j])).height * (float)((Texture)val2).height, 0f, ((Rect)(ref array2[j])).height * (float)((Texture)val2).height * MPSettings.Instance.SpriteBaseline, ((Rect)(ref array2[j])).width * (float)((Texture)val2).width),
					scale = 1.2f
				};
				TMP_SpriteCharacter value = new TMP_SpriteCharacter((uint)list2[j], val3);
				_spriteAsset.spriteGlyphTable[list2[j]] = val3;
				_spriteAsset.spriteCharacterTable[list2[j]] = value;
				Object.Destroy((Object)(object)list[j]);
			}
			_spriteAsset.UpdateLookupTables();
			((TMP_Asset)_spriteAsset).material.mainTexture = (Texture)(object)val2;
		}
	}
	internal class BadgeSettings
	{
	}
	public class BalanceUI : MonoBehaviour
	{
		public enum Types
		{
			TypeA,
			TypeB,
			TypeC
		}

		private const float TypeARotation = 61.62f;

		private const float TypeBRotation = 90f;

		private const float TypeCRotation = 52f;

		private Types Type = Types.TypeB;

		private GameObject _grindUI;

		private Image _grindUIBG;

		private RawImage _grindUIIndicatorImage;

		private GameObject _grindUIIndicator;

		private GameObject _manualUI;

		private Image _manualUIBG;

		private RawImage _manualUIIndicatorImage;

		private GameObject _manualUIIndicator;

		public static BalanceUI Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			Transform val = ((Component)this).transform.Find("Canvas");
			_grindUI = ((Component)val.Find("Grind Balance UI")).gameObject;
			_manualUI = ((Component)val.Find("Manual Balance UI")).gameObject;
			_grindUIBG = ((Component)_grindUI.transform.Find("Image")).GetComponent<Image>();
			_grindUIIndicator = ((Component)_grindUI.transform.Find("Indicator")).gameObject;
			_grindUIIndicatorImage = _grindUIIndicator.GetComponentInChildren<RawImage>(true);
			_manualUIBG = ((Component)_manualUI.transform.Find("Image")).GetComponent<Image>();
			_manualUIIndicator = ((Component)_manualUI.transform.Find("Indicator")).gameObject;
			_manualUIIndicatorImage = _manualUIIndicator.GetComponentInChildren<RawImage>(true);
			_manualUI.SetActive(false);
			_grindUI.SetActive(false);
		}

		private void Update()
		{
			//IL_00fc: 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_0143: 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_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			UIManager uIManager = Core.Instance.UIManager;
			if ((Object)(object)uIManager.gameplay == (Object)null || (Object)(object)uIManager.gameplay.gameplayScreen == (Object)null)
			{
				return;
			}
			if (!((Component)uIManager.gameplay.gameplayScreen).gameObject.activeInHierarchy)
			{
				_grindUI.SetActive(false);
				_manualUI.SetActive(false);
				return;
			}
			WorldHandler instance = WorldHandler.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Player currentPlayer = instance.GetCurrentPlayer();
			if ((Object)(object)currentPlayer == (Object)null)
			{
				return;
			}
			ProSkaterPlayer proSkaterPlayer = ProSkaterPlayer.Get(currentPlayer);
			if ((Object)(object)proSkaterPlayer == (Object)null)
			{
				_grindUI.SetActive(false);
				_manualUI.SetActive(false);
				return;
			}
			float num = 61.62f;
			if (Type == Types.TypeB)
			{
				num = 90f;
			}
			else if (Type == Types.TypeC)
			{
				num = 52f;
			}
			if (!proSkaterPlayer.DidGrind)
			{
				_grindUI.SetActive(false);
			}
			else
			{
				_grindUI.SetActive(true);
				Color color = ((Graphic)_grindUIBG).color;
				color.a = 0.3f;
				if (currentPlayer.ability != null && (currentPlayer.ability is GrindAbility || currentPlayer.ability is HandplantAbility))
				{
					color.a = 1f;
				}
				((Graphic)_grindUIBG).color = color;
				((Graphic)_grindUIIndicatorImage).color = color;
				_grindUIIndicator.transform.localRotation = Quaternion.Euler(0f, 0f, (0f - proSkaterPlayer.GrindBalance.Current) * num);
			}
			if (!proSkaterPlayer.DidManual)
			{
				_manualUI.SetActive(false);
				return;
			}
			_manualUI.SetActive(true);
			Color color2 = ((Graphic)_manualUIBG).color;
			color2.a = 0.3f;
			if (proSkaterPlayer.IsOnManual())
			{
				color2.a = 1f;
			}
			((Graphic)_manualUIBG).color = color2;
			((Graphic)_manualUIIndicatorImage).color = color2;
			_manualUIIndicator.transform.localRotation = Quaternion.Euler(0f, 0f, (0f - proSkaterPlayer.ManualBalance.Current) * num);
		}

		public static void Create()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			MPAssets instance = MPAssets.Instance;
			GameObject val = instance.Bundle.LoadAsset<GameObject>("Balance UI");
			if (MPSettings.Instance.BalanceUIType == Types.TypeB)
			{
				val = instance.Bundle.LoadAsset<GameObject>("Balance UI B");
			}
			else if (MPSettings.Instance.BalanceUIType == Types.TypeC)
			{
				val = instance.Bundle.LoadAsset<GameObject>("Balance UI C");
			}
			GameObject obj = Object.Instantiate<GameObject>(val);
			obj.transform.SetParent(((Component)Core.Instance.UIManager).transform, false);
			obj.AddComponent<BalanceUI>().Type = MPSettings.Instance.BalanceUIType;
		}
	}
	public class ChatUI : MonoBehaviour
	{
		public enum States
		{
			None,
			Unfocused,
			Focused
		}

		private const int MaxMessages = 250;

		private Button _sendButton;

		private TMP_InputField _inputField;

		private ScrollRect _scrollRect;

		private Image _scrollRectImage;

		private Image[] _scrollBarImages;

		private GameObject _chatWindow;

		private TextMeshProUGUI _referenceText;

		private List<TextMeshProUGUI> _messages = new List<TextMeshProUGUI>();

		public Action<string> OnTrySendMessage;

		private const float TimeForMessagesToHide = 30f;

		private bool _messagesHidden;

		private float _messageHideTimer;

		public static ChatUI Instance { get; private set; }

		private float FontSize => MPSettings.Instance.ChatFontSize;

		public States State { get; private set; }

		private void Awake()
		{
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			Instance = this;
			_chatWindow = ((Component)((Component)this).transform.Find("Canvas").Find("Chat Window")).gameObject;
			_sendButton = ((Component)_chatWindow.transform.Find("Send Button")).GetComponent<Button>();
			_inputField = ((Component)_chatWindow.transform.Find("Input Field")).GetComponent<TMP_InputField>();
			_inputField.characterLimit = 256;
			_scrollRect = ((Component)_chatWindow.transform.Find("Scroll View")).GetComponent<ScrollRect>();
			_scrollBarImages = ((Component)((Component)_scrollRect).transform.Find("Scrollbar Vertical")).GetComponentsInChildren<Image>(true);
			_scrollRectImage = ((Component)_scrollRect).GetComponent<Image>();
			_referenceText = ((Component)((Transform)_scrollRect.content).Find("Text")).GetComponent<TextMeshProUGUI>();
			((Component)_referenceText).gameObject.SetActive(false);
			((UnityEvent)_sendButton.onClick).AddListener(new UnityAction(TrySendChatMessage));
			((TMP_Text)_referenceText).spriteAsset = MPAssets.Instance.Sprites;
			ClientController.PacketReceived = (Action<Packets, Packet>)Delegate.Combine(ClientController.PacketReceived, new Action<Packets, Packet>(OnPacketReceived));
			SetState(States.Unfocused);
		}

		private void OnDestroy()
		{
			ClientController.PacketReceived = (Action<Packets, Packet>)Delegate.Remove(ClientController.PacketReceived, new Action<Packets, Packet>(OnPacketReceived));
		}

		private void OnPacketReceived(Packets packetId, Packet packet)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			MPSettings instance = MPSettings.Instance;
			ClientController instance2 = ClientController.Instance;
			_ = instance2.ClientLobbyManager;
			if ((int)packetId != 27)
			{
				if ((int)packetId == 32)
				{
					HandleServerMessage((ServerChat)packet);
				}
			}
			else
			{
				if (!instance.InviteMessages)
				{
					return;
				}
				ServerLobbyInvite val = (ServerLobbyInvite)packet;
				ushort inviterId = val.InviterId;
				ushort inviteeId = val.InviteeId;
				uint lobbyId = val.LobbyId;
				if (inviteeId == instance2.LocalID)
				{
					string playerDisplayName = MPUtility.GetPlayerDisplayName(instance2.Players[inviterId].ClientState);
					string lobbyName = instance2.ClientLobbyManager.GetLobbyName(lobbyId);
					string format = "{0} Has invited you to their {1} lobby.";
					if (instance2.GetUser(inviterId).HasTag("elite"))
					{
						format = "<color=yellow>A {0} is challenging you to a {1}.</color>";
					}
					AddMessage(string.Format(format, playerDisplayName, lobbyName));
				}
			}
		}

		private void HandleServerMessage(ServerChat serverMessage)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			MPSettings instance = MPSettings.Instance;
			string text = serverMessage.Message;
			if ((int)serverMessage.MessageType == 4)
			{
				Clear();
			}
			else
			{
				if (((int)serverMessage.MessageType == 1 && !instance.LeaveJoinMessages) || ((int)serverMessage.MessageType == 3 && !instance.AFKMessages))
				{
					return;
				}
				string text2 = serverMessage.Author;
				if (string.IsNullOrEmpty(text2))
				{
					text2 = "";
				}
				text2 = MPUtility.GetPlayerDisplayName(text2);
				if (AprilClient.GetAprilEventEnabled())
				{
					text2 = $"<sprite={AprilClient.GetBadgeForName(serverMessage.Author)}> {text2}";
				}
				int[] badges = serverMessage.Badges;
				foreach (int num in badges)
				{
					text2 = $"<sprite={num}> {text2}";
				}
				if ((int)serverMessage.MessageType == 0)
				{
					text = TMPFilter.CloseAllTags(TMPFilter.FilterTags(text, MPSettings.Instance.ChatCriteria));
					if (ProfanityFilter.TMPContainsProfanity(text))
					{
						text = ((!MPSettings.Instance.FilterProfanity) ? (text + "<sprite=37><color=red>[FILTERED]</color>") : "I said a naughty word!");
					}
					text = MPUtility.ParseMessageEmojis(text);
					text = $"{text2} : {text}";
				}
				else if (!string.IsNullOrEmpty(serverMessage.Author))
				{
					text = string.Format(text, text2);
				}
				AddMessage(text);
			}
		}

		public void UpdateSizes()
		{
			foreach (TextMeshProUGUI message in _messages)
			{
				((TMP_Text)message).fontSize = FontSize;
			}
		}

		private void Clear()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			foreach (TextMeshProUGUI message in _messages)
			{
				Object.Destroy((Object)(object)((Component)message).gameObject);
			}
			_messages.Clear();
			LayoutRebuilder.ForceRebuildLayoutImmediate(ComponentExtensions.RectTransform((Component)(object)_scrollRect));
			_scrollRect.normalizedPosition = new Vector2(0f, 0f);
		}

		public void AddMessage(string text)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			bool flag = true;
			if (State == States.Focused && _scrollRect.normalizedPosition.y > 0.1f)
			{
				flag = false;
			}
			if (State == States.Focused && MPSettings.Instance.DontAutoScrollChatIfFocused)
			{
				flag = false;
			}
			if (MPSettings.Instance.ShowChat)
			{
				ShowMessages();
			}
			if (_messages.Count >= 250)
			{
				Object.Destroy((Object)(object)((Component)_messages[0]).gameObject);
				_messages.RemoveAt(0);
			}
			GameObject obj = Object.Instantiate<GameObject>(((Component)_referenceText).gameObject);
			obj.SetActive(true);
			obj.transform.SetParent((Transform)(object)_scrollRect.content, false);
			TextMeshProUGUI component = obj.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = text;
			((TMP_Text)component).fontSize = FontSize;
			_messages.Add(component);
			LayoutRebuilder.ForceRebuildLayoutImmediate(ComponentExtensions.RectTransform((Component)(object)_scrollRect));
			if (flag)
			{
				_scrollRect.normalizedPosition = new Vector2(0f, 0f);
			}
		}

		private bool CanOpen()
		{
			//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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (MPUtility.AnyMenusOpen())
			{
				return false;
			}
			PlayerControllerMapIDCollection allCurrentEnabledControllerMapCategoryIDs = Core.Instance.gameInput.GetAllCurrentEnabledControllerMapCategoryIDs(0);
			if (allCurrentEnabledControllerMapCategoryIDs.controllerMapCategoryIDs.Contains(0) && allCurrentEnabledControllerMapCategoryIDs.controllerMapCategoryIDs.Contains(6))
			{
				return !Core.Instance.IsCorePaused;
			}
			return false;
		}

		public void TrySendChatMessage()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			string text = _inputField.text;
			OnTrySendMessage?.Invoke(text);
			_inputField.text = "";
			SetState(States.Unfocused);
			if (TMPFilter.IsValidChatMessage(text))
			{
				ClientController.Instance.SendPacket((Packet)new ClientChat(text), (SendModes)2, (NetChannels)4);
				if (text[0] == '/')
				{
					ProcessLocalCommand(text);
				}
			}
		}

		private void ProcessLocalCommand(string message)
		{
			string[] array = message.Substring(1).Split(new char[1] { ' ' });
			ClientLogger.Log("Processing chat command " + array[0]);
			string text = array[0];
			if (text == null)
			{
				return;
			}
			switch (text.Length)
			{
			case 6:
				switch (text[0])
				{
				case 'e':
					if (text == "emojis")
					{
						string text2 = "Available emojis:\n";
						KeyValuePair<string, int>[] array2 = MPAssets.Instance.Emojis.Sprites.OrderBy<KeyValuePair<string, int>, string>((KeyValuePair<string, int> x) => x.Key[1].ToString(), StringComparer.InvariantCultureIgnoreCase).ToArray();
						for (int i = 0; i < array2.Length; i++)
						{
							KeyValuePair<string, int> keyValuePair = array2[i];
							text2 += $"{keyValuePair.Key} - <sprite={keyValuePair.Value}>\n";
						}
						AddMessage(text2);
					}
					break;
				case 'p':
					if (text == "parent")
					{
						ushort playerId = 0;
						if (array.Length > 1)
						{
							playerId = ushort.Parse(array[1]);
						}
						ClientController.Instance.AttachToPlayerID(playerId);
					}
					break;
				}
				break;
			case 4:
				switch (text[0])
				{
				case 'h':
					if (text == "hide")
					{
						MPSettings.Instance.ShowChat = false;
					}
					break;
				case 's':
					if (text == "show")
					{
						MPSettings.Instance.ShowChat = true;
					}
					break;
				case 'j':
					if (text == "jill" && ClientController.Instance.GetLocalUser().IsModerator)
					{
						Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
						SpecialSkinManager.Instance.ApplySpecialSkinToPlayer(currentPlayer, (SpecialSkins)5);
					}
					break;
				}
				break;
			case 5:
				if (text == "clear")
				{
					Clear();
				}
				break;
			case 8:
				if (text == "prophunt" && ClientController.Instance.GetLocalUser().IsModerator)
				{
					GamemodeSettings gamemodeSettings = GamemodeFactory.GetGamemodeSettings((GamemodeIDs)6);
					SavedGamemodeSettings savedSettings = MPSaveData.Instance.GetSavedSettings((GamemodeIDs)6);
					if (savedSettings != null)
					{
						gamemodeSettings.ApplySaved(savedSettings);
					}
					ClientController.Instance.ClientLobbyManager.SetGamemode((GamemodeIDs)6, gamemodeSettings);
				}
				break;
			case 7:
				break;
			}
		}

		private void LateUpdate()
		{
			if (ShouldDisplay())
			{
				_chatWindow.SetActive(true);
				switch (State)
				{
				case States.Unfocused:
					UnfocusedUpdate();
					break;
				case States.Focused:
					FocusedUpdate();
					break;
				}
			}
			else
			{
				SetState(States.Unfocused);
				_chatWindow.SetActive(false);
			}
		}

		private void HideMessages()
		{
			_messageHideTimer = 30f;
			_messagesHidden = true;
			((Component)_scrollRect).gameObject.SetActive(false);
		}

		private void ShowMessages()
		{
			_messageHideTimer = 0f;
			_messagesHidden = false;
			((Component)_scrollRect).gameObject.SetActive(true);
		}

		private void UnfocusedUpdate()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			_scrollRect.normalizedPosition = new Vector2(0f, 0f);
			_messageHideTimer += Time.deltaTime;
			if (_messageHideTimer >= 30f || !MPSettings.Instance.ShowChat)
			{
				HideMessages();
			}
			if (Input.GetKeyDown(MPSettings.Instance.ChatKey) && CanOpen())
			{
				SetState(States.Focused);
			}
		}

		private void FocusedUpdate()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			InputUtils.Override = true;
			try
			{
				_messageHideTimer = 0f;
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
				if ((Input.GetMouseButtonDown(0) || Input.GetMouseButtonDown(1) || Input.GetMouseButtonDown(2)) && !RectTransformUtility.RectangleContainsScreenPoint(GameObjectExtensions.RectTransform(_chatWindow), Vector2.op_Implicit(Input.mousePosition)))
				{
					SetState(States.Unfocused);
				}
				if (Input.GetKeyDown((KeyCode)279))
				{
					_scrollRect.normalizedPosition = new Vector2(0f, 0f);
				}
				if (Input.GetKeyDown((KeyCode)271) || (Input.GetKeyDown((KeyCode)13) && (Object)(object)EventSystem.current.currentSelectedGameObject == (Object)(object)((Component)_inputField).gameObject))
				{
					TrySendChatMessage();
				}
				if (Input.GetKeyDown((KeyCode)27))
				{
					SetState(States.Unfocused);
				}
			}
			finally
			{
				InputUtils.Override = false;
			}
		}

		public void SetState(States newState)
		{
			if (State != newState)
			{
				State = newState;
				switch (State)
				{
				case States.Unfocused:
					EnterUnfocusedState();
					break;
				case States.Focused:
					EnterFocusedState();
					break;
				}
			}
		}

		private void EnterUnfocusedState()
		{
			Cursor.visible = false;
			Cursor.lockState = (CursorLockMode)1;
			GameInput gameInput = Core.Instance.GameInput;
			gameInput.DisableAllControllerMaps(0);
			gameInput.EnableControllerMaps(BaseModule.IN_GAME_INPUT_MAPS, 0);
			if ((Object)(object)SpectatorController.Instance != (Object)null)
			{
				gameInput.EnableControllerMaps(BaseModule.MENU_INPUT_MAPS, 0);
			}
			((Behaviour)_scrollRectImage).enabled = false;
			((Component)_inputField).gameObject.SetActive(false);
			((Component)_sendButton).gameObject.SetActive(false);
			Image[] scrollBarImages = _scrollBarImages;
			for (int i = 0; i < scrollBarImages.Length; i++)
			{
				((Behaviour)scrollBarImages[i]).enabled = false;
			}
			EventSystem.current.SetSelectedGameObject((GameObject)null);
		}

		private void EnterFocusedState()
		{
			Core.Instance.GameInput.DisableAllControllerMaps(0);
			ShowMessages();
			((Behaviour)_scrollRectImage).enabled = true;
			((Component)_inputField).gameObject.SetActive(true);
			((Component)_sendButton).gameObject.SetActive(true);
			Image[] scrollBarImages = _scrollBarImages;
			for (int i = 0; i < scrollBarImages.Length; i++)
			{
				((Behaviour)scrollBarImages[i]).enabled = true;
			}
			((Selectable)_inputField).Select();
		}

		private bool ShouldDisplay()
		{
			UIManager uIManager = Core.Instance.UIManager;
			if ((Object)(object)uIManager == (Object)null || (Object)(object)uIManager.gameplay == (Object)null || (Object)(object)uIManager.gameplay.gameplayScreen == (Object)null)
			{
				return false;
			}
			if (!((Component)uIManager.gameplay.gameplayScreen).gameObject.activeInHierarchy && (Object)(object)SpectatorController.Instance == (Object)null)
			{
				return false;
			}
			return true;
		}

		public static void Create()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			GameObject obj = Object.Instantiate<GameObject>(MPAssets.Instance.Bundle.LoadAsset<GameObject>("Chat UI"));
			obj.transform.SetParent(((Component)Core.Instance.UIManager).transform, false);
			obj.AddComponent<ChatUI>();
		}
	}
	public static class ClientConstants
	{
		public const string ChatMessage = "{0} : {1}";

		public const string LobbyChatMessage = "{0} (LOBBY) : {1}";

		public const string LobbyInviteMessage = "{0} Has invited you to their {1} lobby.";

		public const string DeathMessage = "{0} died!";

		public const int MinimumPlayersToCheer = 2;

		public const float PlayerInterpolation = 12f;

		public const float PlayerGraffitiDistance = 1f;

		public const float PlayerGraffitiDownDistance = 1f;

		public const float AFKTime = 300f;

		public const float InfrequentUpdateRate = 1f;

		public static int GrindDirectionHash = Animator.StringToHash("grindDirection");

		public static int PhoneDirectionXHash = Animator.StringToHash("phoneDirectionX");

		public static int PhoneDirectionYHash = Animator.StringToHash("phoneDirectionY");

		public static int TurnDirection1Hash = Animator.StringToHash("turnDirectionX");

		public static int TurnDirection2Hash = Animator.StringToHash("turnDirectionX2");

		public static int TurnDirection3Hash = Animator.StringToHash("turnDirectionX3");

		public static int TurnDirectionSkateboardHash = Animator.StringToHash("turnDirectionSkateboard");

		public static int MissingAnimationHash = Animator.StringToHash("softBounce17");
	}
	public class ClientController : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <AttemptReconnect>d__75 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ClientController <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AttemptReconnect>d__75(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				ClientController clientController = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSecondsRealtime(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					clientController.Disconnect();
					clientController.Connect();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static bool SeenMOTD = false;

		public Dictionary<int, int> PlayerCountByStage = new Dictionary<int, int>();

		public ClientLobbyManager ClientLobbyManager;

		public Dictionary<Player, MPPlayer> MultiplayerPlayerByPlayer = new Dictionary<Player, MPPlayer>();

		public Dictionary<ushort, MPPlayer> Players = new Dictionary<ushort, MPPlayer>();

		public ushort LocalID;

		public float TickRate = 1f / 32f;

		public string Address = "";

		public int Port;

		public GraffitiGame CurrentGraffitiGame;

		public static Action ServerDisconnect;

		public static Action ServerConnect;

		public static Action<ushort> PlayerDisconnected;

		public static Action<Packets, Packet> PacketReceived;

		public static Action ClientStatesUpdate;

		public string AuthKey;

		public bool InfrequentClientStateUpdateQueued;

		public ServerState ServerState = new ServerState();

		private static Dictionary<int, Action<ushort, byte[]>> _customPacketHandlers = new Dictionary<int, Action<ushort, byte[]>>();

		private PlayerComponent _cachedPlayerComponent;

		private INetClient _client;

		private float _tickTimer;

		private float _infrequentUpdateTimer;

		private bool _handShook;

		private MPSettings _mpSettings;

		private AuthUser _cachedLocalUser;

		public Player PlayerAttached;

		private Vector3 AttachedPosition;

		private Vector3 AttachedHeading;

		private List<Plane[]> _frustumList = new List<Plane[]>();

		public static float DeltaTime { get; private set; }

		public static ClientController Instance { get; private set; }

		public bool Connected
		{
			get
			{
				if (_client != null && _client.IsConnected)
				{
					return _handShook;
				}
				return false;
			}
		}

		public PlayerComponent LocalPlayerComponent
		{
			get
			{
				if ((Object)(object)_cachedPlayerComponent == (Object)null)
				{
					_cachedPlayerComponent = PlayerComponent.Get(WorldHandler.instance.GetCurrentPlayer());
				}
				return _cachedPlayerComponent;
			}
		}

		private INetworkingInterface NetworkingInterface => NetworkingEnvironment.NetworkingInterface;

		public static void RegisterCustomPacketHandler(string customPacketId, Action<ushort, byte[]> handler)
		{
			RegisterCustomPacketHandler(Compression.HashString(customPacketId), handler);
		}

		public static void UnregisterCustomPacketHandler(string customPacketId)
		{
			UnregisterCustomPacketHandler(Compression.HashString(customPacketId));
		}

		public static void RegisterCustomPacketHandler(int customPacketId, Action<ushort, byte[]> handler)
		{
			_customPacketHandlers[customPacketId] = handler;
		}

		public static void UnregisterCustomPacketHandler(int customPacketId)
		{
			_customPacketHandlers.Remove(customPacketId);
		}

		public void BroadcastCustomPacket(byte[] data, string customPacketId, SendModes sendMode = 2)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			BroadcastCustomPacket(data, Compression.HashString(customPacketId), sendMode);
		}

		public void BroadcastCustomPacket(byte[] data, int customPacketId, SendModes sendMode = 2)
		{
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			ClientCustomPacket packet = new ClientCustomPacket
			{
				CustomPacketId = customPacketId,
				Data = data,
				SendMode = sendMode,
				TargetMode = (SendTargets)0
			};
			SendPacket((Packet)(object)packet, sendMode, (NetChannels)6);
		}

		public void BroadcastCustomPacketToCurrentLobby(byte[] data, string customPacketId, SendModes sendMode = 2)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			BroadcastCustomPacketToCurrentLobby(data, Compression.HashString(customPacketId), sendMode);
		}

		public void BroadcastCustomPacketToCurrentLobby(byte[] data, int customPacketId, SendModes sendMode = 2)
		{
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			ClientCustomPacket packet = new ClientCustomPacket
			{
				CustomPacketId = customPacketId,
				Data = data,
				SendMode = sendMode,
				TargetMode = (SendTargets)1
			};
			SendPacket((Packet)(object)packet, sendMode, (NetChannels)6);
		}

		public void SendCustomPacketToPlayer(byte[] data, string customPacketId, ushort targetPlayer, SendModes sendMode = 2)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			SendCustomPacketToPlayer(data, Compression.HashString(customPacketId), targetPlayer, sendMode);
		}

		public void SendCustomPacketToPlayer(byte[] data, int customPacketId, ushort targetPlayer, SendModes sendMode = 2)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			SendCustomPacketToPlayers(data, customPacketId, new ushort[1] { targetPlayer }, sendMode);
		}

		public void SendCustomPacketToPlayers(byte[] data, string customPacketId, ushort[] targetPlayers, SendModes sendMode = 2)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			SendCustomPacketToPlayers(data, Compression.HashString(customPacketId), targetPlayers, sendMode);
		}

		public void SendCustomPacketToPlayers(byte[] data, int customPacketId, ushort[] targetPlayers, SendModes sendMode = 2)
		{
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002a: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			ClientCustomPacket packet = new ClientCustomPacket
			{
				CustomPacketId = customPacketId,
				Data = data,
				SendMode = sendMode,
				TargetMode = (SendTargets)2,
				Targets = targetPlayers
			};
			SendPacket((Packet)(object)packet, sendMode, (NetChannels)6);
		}

		public void AttachToPlayerID(ushort playerId)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (Players.TryGetValue(playerId, out var value) && (Object)(object)value.Player != (Object)null)
			{
				Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
				PlayerAttached = value.Player;
				AttachedPosition = ((Component)value.Player).transform.InverseTransformPoint(((Component)currentPlayer).transform.position);
				AttachedHeading = ((Component)value.Player).transform.InverseTransformDirection(((Component)currentPlayer).transform.forward);
			}
			else
			{
				PlayerAttached = null;
			}
		}

		private void Awake()
		{
			Instance = this;
			_mpSettings = MPSettings.Instance;
			ClientLobbyManager = new ClientLobbyManager();
			ClientLobbyManager.LobbiesUpdated = (Action)Delegate.Combine(ClientLobbyManager.LobbiesUpdated, new Action(OnLobbiesUpdated));
			MPPlayer.OptimizationActions.Clear();
		}

		public int GetPlayerCountForStage(Stage stage)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected I4, but got Unknown
			if (PlayerCountByStage.TryGetValue((int)stage, out var value))
			{
				return value;
			}
			return 0;
		}

		public AuthUser GetUser(ushort playerId)
		{
			if (Players.TryGetValue(playerId, out var value) && value.ClientState != null)
			{
				return value.ClientState.User;
			}
			return null;
		}

		public AuthUser GetLocalUser()
		{
			if (!Players.ContainsKey(LocalID))
			{
				return _cachedLocalUser;
			}
			return GetUser(LocalID);
		}

		public void Connect()
		{
			ClientLogger.Log($"Connecting to {Address}:{Port}");
			_client = NetworkingInterface.CreateClient();
			Task.Run(delegate
			{
				_client.Connect(Address, Port);
			});
			INetClient client = _client;
			client.Connected = (EventHandler)Delegate.Combine(client.Connected, new EventHandler(OnConnected));
			INetClient client2 = _client;
			client2.Disconnected = (EventHandler<DisconnectedEventArgs>)Delegate.Combine(client2.Disconnected, new EventHandler<DisconnectedEventArgs>(OnDisconnect));
			INetClient client3 = _client;
			client3.ConnectionFailed = (EventHandler<ConnectionFailedEventArgs>)Delegate.Combine(client3.ConnectionFailed, new EventHandler<ConnectionFailedEventArgs>(OnConnectionFailed));
			INetClient client4 = _client;
			client4.MessageReceived = (EventHandler<MessageReceivedEventArgs>)Delegate.Combine(client4.MessageReceived, new EventHandler<MessageReceivedEventArgs>(OnMessageReceived));
			ServerConnect?.Invoke();
		}

		public void Disconnect()
		{
			foreach (KeyValuePair<ushort, MPPlayer> player in Players)
			{
				player.Value.Delete();
			}
			Players.Clear();
			_handShook = false;
			LocalID = 0;
			if (_client != null)
			{
				INetClient client = _client;
				client.Connected = (EventHandler)Delegate.Remove(client.Connected, new EventHandler(OnConnected));
				INetClient client2 = _client;
				client2.Disconnected = (EventHandler<DisconnectedEventArgs>)Delegate.Remove(client2.Disconnected, new EventHandler<DisconnectedEventArgs>(OnDisconnect));
				INetClient client3 = _client;
				client3.ConnectionFailed = (EventHandler<ConnectionFailedEventArgs>)Delegate.Remove(client3.ConnectionFailed, new EventHandler<ConnectionFailedEventArgs>(OnConnectionFailed));
				INetClient client4 = _client;
				client4.MessageReceived = (EventHandler<MessageReceivedEventArgs>)Delegate.Remove(client4.MessageReceived, new EventHandler<MessageReceivedEventArgs>(OnMessageReceived));
				_client.Disconnect();
			}
			_client = null;
			ServerDisconnect?.Invoke();
		}

		public void SendGenericEvent(GenericEvents ev, SendModes sendMode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			SendPacket((Packet)new PlayerGenericEvent(ev), sendMode, (NetChannels)0);
		}

		public void SendPacket(Packet packet, SendModes sendMode, NetChannels channel)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (_client != null)
			{
				IMessage val = PacketFactory.MessageFromPacket(packet, sendMode, channel);
				_client.Send(val);
			}
		}

		public static ClientController Create(string address, int port)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			ClientController clientController = new GameObject("Client Controller").AddComponent<ClientController>();
			clientController.Address = address;
			clientController.Port = port;
			clientController.Connect();
			return clientController;
		}

		private ClientVisualState CreateVisualStatePacket(Player player)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_007f: Expected I4, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected I4, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Invalid comparison between Unknown and I4
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_043d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			//IL_0458: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: 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)
			//IL_019d: Invalid comparison between Unknown and I4
			//IL_0243: 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_04a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04da: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			PlayerStates val = (PlayerStates)0;
			if ((Object)(object)CurrentGraffitiGame != (Object)null)
			{
				val = (PlayerStates)1;
			}
			PublicToilet currentToilet = MPUtility.GetCurrentToilet();
			if ((Object)(object)currentToilet != (Object)null)
			{
				val = (PlayerStates)2;
			}
			if (player.IsDead())
			{
				val = (PlayerStates)3;
			}
			PlayerComponent localPlayerComponent = LocalPlayerComponent;
			ClientVisualState val2 = new ClientVisualState();
			val2.State = val;
			val2.AFK = localPlayerComponent.AFK;
			val2.MoveStyleSkin = (byte)Core.Instance.SaveManager.CurrentSaveSlot.GetCharacterProgress(player.character).moveStyleSkin;
			val2.MoveStyle = (int)player.moveStyleEquipped;
			val2.Chibi = localPlayerComponent.Chibi;
			val2.Disguised = localPlayerComponent.HasPropDisguise;
			val2.DisguiseId = localPlayerComponent.DisguiseID;
			val2.Ignore = localPlayerComponent.LocalIgnore;
			MPSaveData.MPCharacterData characterData = MPSaveData.Instance.GetCharacterData(player.character);
			if (characterData != null)
			{
				val2.MPMoveStyleSkin = characterData.MPMoveStyleSkin;
			}
			switch ((int)val)
			{
			case 0:
			case 3:
			{
				val2.MoveStyleEquipped = player.usingEquippedMovestyle;
				val2.Position = ((Component)player).gameObject.transform.position.ToSystemVector3();
				val2.VisualPosition = player.visualTf.localPosition.ToSystemVector3();
				val2.Rotation = ((Component)player).gameObject.transform.rotation.ToSystemQuaternion();
				val2.VisualRotation = player.visualTf.localRotation.ToSystemQuaternion();
				val2.Velocity = player.motor._rigidbody.velocity.ToSystemVector3();
				val2.GrindDirection = player.anim.GetFloat(ClientConstants.GrindDirectionHash);
				val2.SprayCanHeld = (int)player.spraycanState == 1 || (int)player.spraycanState == 2;
				val2.PhoneHeld = player.characterVisual.phoneActive;
				val2.PhoneDirectionX = player.anim.GetFloat(ClientConstants.PhoneDirectionXHash);
				val2.PhoneDirectionY = player.anim.GetFloat(ClientConstants.PhoneDirectionYHash);
				val2.TurnDirection1 = player.anim.GetFloat(ClientConstants.TurnDirection1Hash);
				val2.TurnDirection2 = player.anim.GetFloat(ClientConstants.TurnDirection2Hash);
				val2.TurnDirection3 = player.anim.GetFloat(ClientConstants.TurnDirection3Hash);
				val2.TurnDirectionSkateboard = player.anim.GetFloat(ClientConstants.TurnDirectionSkateboardHash);
				val2.BoostpackEffectMode = (byte)player.characterVisual.boostpackEffectMode;
				val2.FrictionEffectMode = (byte)player.characterVisual.frictionEffectMode;
				if ((Object)(object)player.characterVisual.dustParticles != (Object)null)
				{
					EmissionModule emission = player.characterVisual.dustParticles.emission;
					MinMaxCurve rateOverTime = ((EmissionModule)(ref emission)).rateOverTime;
					val2.DustEmissionRate = (byte)((MinMaxCurve)(ref rateOverTime)).constant;
				}
				val2.CurrentAnimation = player.curAnim;
				val2.CurrentAnimationTime = player.curAnimActiveTime;
				val2.Hitbox = player.hitbox.activeSelf;
				val2.HitboxLeftLeg = player.hitboxLeftLeg.activeSelf;
				val2.HitboxRightLeg = player.hitboxRightLeg.activeSelf;
				val2.HitboxUpperBody = player.hitboxUpperBody.activeSelf;
				val2.HitboxAerial = player.airialHitbox.activeSelf;
				val2.HitboxRadial = player.radialHitbox.activeSelf;
				val2.HitboxSpray = player.sprayHitbox.activeSelf;
				int currentAnimation = default(int);
				if (BunchOfEmotesSupport.TryGetCustomAnimationHashByGameAnimation(val2.CurrentAnimation, ref currentAnimation))
				{
					val2.BoEAnimation = true;
					val2.CurrentAnimation = currentAnimation;
				}
				break;
			}
			case 1:
			{
				Quaternion quaternion = Quaternion.LookRotation(-((Component)CurrentGraffitiGame.gSpot).transform.forward, Vector3.up);
				val2.Position = (((Component)CurrentGraffitiGame.gSpot).transform.position + ((Component)CurrentGraffitiGame.gSpot).transform.forward * 1f + -((Component)CurrentGraffitiGame.gSpot).transform.up * 1f).ToSystemVector3();
				val2.Rotation = quaternion.ToSystemQuaternion();
				val2.BoostpackEffectMode = (byte)CurrentGraffitiGame.characterPuppet.boostpackEffectMode;
				break;
			}
			case 2:
				val2.Position = (((Component)currentToilet).transform.position + Vector3.up * 0.2f - ((Component)currentToilet).transform.forward * 0.2f).ToSystemVector3();
				val2.Rotation = (((Component)currentToilet).transform.rotation * Quaternion.Euler(0f, 180f, 0f)).ToSystemQuaternion();
				val2.CurrentAnimation = Animator.StringToHash("idle");
				break;
			}
			if (val2.Disguised)
			{
				val2.VisualPosition = localPlayerComponent.DisguiseGameObject.transform.localPosition.ToSystemVector3();
				val2.VisualRotation = localPlayerComponent.DisguiseGameObject.transform.localRotation.ToSystemQuaternion();
				val2.DisguiseScale = localPlayerComponent.DisguiseGameObject.transform.localScale.ToSystemVector3();
			}
			return val2;
		}

		private void SendVisualState()
		{
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			if (!((Object)(object)currentPlayer == (Object)null))
			{
				ClientVisualState packet = CreateVisualStatePacket(currentPlayer);
				SendPacket((Packet)(object)packet, (SendModes)0, (NetChannels)3);
			}
		}

		private void Tick()
		{
			INetClient client = _client;
			if (client != null)
			{
				client.Update();
			}
			if (Connected)
			{
				SendVisualState();
			}
			foreach (KeyValuePair<ushort, MPPlayer> player in Players)
			{
				player.Value.TickUpdate();
			}
			ClientLobbyManager.OnTick();
		}

		private void OnLobbiesUpdated()
		{
			foreach (KeyValuePair<ushort, MPPlayer> player in Players)
			{
				player.Value.UpdateLobby();
				player.Value.UpdateNameplate();
			}
		}

		private void Update()
		{
			//IL_0030: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: 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_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			MPSettings instance = MPSettings.Instance;
			if ((Object)(object)PlayerAttached != (Object)null)
			{
				Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
				((Component)currentPlayer).transform.position = ((Component)PlayerAttached).transform.TransformPoint(AttachedPosition);
				Quaternion rotation = Quaternion.LookRotation(((Component)PlayerAttached).transform.TransformDirection(AttachedHeading), Vector3.up);
				((Component)currentPlayer).transform.rotation = rotation;
				currentPlayer.SetVisualRot(((Component)currentPlayer).transform.rotation, false);
				currentPlayer.SetRotation(((Component)currentPlayer).transform.rotation);
			}
			bool flag = (Object)(object)MPUtility.GetCurrentToilet() != (Object)null;
			_tickTimer += Time.deltaTime;
			_infrequentUpdateTimer += Time.deltaTime;
			if (_tickTimer >= TickRate)
			{
				DeltaTime = _tickTimer;
				Tick();
				_tickTimer = 0f;
			}
			if (_infrequentUpdateTimer >= 1f)
			{
				InfrequentUpdate();
				_infrequentUpdateTimer = 0f;
			}
			_frustumList.Clear();
			WorldHandler instance2 = WorldHandler.instance;
			bool hidePlayersOutOfView = instance.HidePlayersOutOfView;
			_ = instance.PlayerDrawDistance;
			if (hidePlayersOutOfView)
			{
				Camera currentCamera = instance2.CurrentCamera;
				_frustumList.Add(GeometryUtility.CalculateFrustumPlanes(currentCamera));
				PlayerPhoneCameras instance3 = PlayerPhoneCameras.Instance;
				if ((Object)(object)instance3 != (Object)null && ((Behaviour)instance3).isActiveAndEnabled)
				{
					foreach (KeyValuePair<PhoneCam, Camera> camera in instance3.Cameras)
					{
						if (((Behaviour)camera.Value).enabled)
						{
							_frustumList.Add(GeometryUtility.CalculateFrustumPlanes(camera.Value));
						}
					}
				}
			}
			Vector3 position = ((Component)instance2.currentCamera).transform.position;
			List<StageChunk> stageChunks = null;
			if (instance.HidePlayersInInactiveChunks)
			{
				stageChunks = instance2.SceneObjectsRegister.stageChunks;
			}
			foreach (KeyValuePair<ushort, MPPlayer> player in Players)
			{
				bool flag2 = flag;
				Vector3 val;
				if (hidePlayersOutOfView && !flag)
				{
					if ((Object)(object)player.Value.Player != (Object)null)
					{
						val = ((Component)player.Value.Player).transform.position - position;
						if (((Vector3)(ref val)).sqrMagnitude >= instance.PlayerDrawDistance)
						{
							flag2 = true;
							goto IL_0266;
						}
					}
					if (!player.Value.CalculateVisibility(_frustumList, stageChunks))
					{
						flag2 = true;
					}
				}
				goto IL_0266;
				IL_0266:
				bool lod = false;
				if (!flag2 && (Object)(object)player.Value.Player != (Object)null && instance.PlayerLodEnabled)
				{
					val = ((Component)player.Value.Player).transform.position - position;
					if (((Vector3)(ref val)).sqrMagnitude >= instance.PlayerLodDistance)
					{
						lod = true;
					}
				}
				player.Value.FrameUpdate(flag2, lod);
			}
			if (MPPlayer.OptimizationActions.Count > 0)
			{
				Action action = MPPlayer.OptimizationActions[0];
				MPPlayer.OptimizationActions.RemoveAt(0);
				action?.Invoke();
			}
			ClientLobbyManager.OnUpdate();
		}

		private void InfrequentUpdate()
		{
			if (InfrequentClientStateUpdateQueued)
			{
				SendClientState();
			}
		}

		private void OnClientDisconnected(object sender, ushort id)
		{
			if (Players.TryGetValue(id, out var value))
			{
				value.Delete();
				Players.Remove(id);
			}
			PlayerDisconnected?.Invoke(id);
		}

		private void ExecuteGenericEvent(GenericEvents ev, MPPlayer player)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected I4, but got Unknown
			//IL_0049: 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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			switch ((int)ev)
			{
			case 0:
				if (!((Object)(object)player.Player == (Object)null) && !player.ShouldIgnore())
				{
					player.Player.characterVisual.SetSpraycan(true, player.Player.character);
					player.Player.SetSpraycanState((SpraycanState)3);
				}
				break;
			case 1:
				player.Teleporting = true;
				break;
			case 2:
				if (!((Object)(object)player.Player == (Object)null))
				{
					player.Player.RemoveGraffitiSlash();
				}
				break;
			case 3:
				if (player.ClientState != null && MPSettings.Instance.DeathMessages)
				{
					ChatUI.Instance.AddMessage($"{MPUtility.GetPlayerDisplayName(player.ClientState)} died!");
				}
				break;
			case 4:
				if (!((Object)(object)player.Player == (Object)null) && !player.ShouldIgnore())
				{
					player.Player.AudioManager.PlaySfxGameplay(player.Player.moveStyle, (AudioClipID)255, player.Player.playerOneShotAudioSource, 0f);
					player.Player.CreateCircleDustEffect(-((Component)player.Player).transform.up);
				}
				break;
			}
		}

		private void OnMessageReceived(object sender, MessageReceivedEventArgs e)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected I4, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected I4, but got Unknown
			//IL_07d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07db: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Invalid comparison between Unknown and I4
			//IL_080e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0815: Expected O, but got Unknown
			//IL_081c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0828: 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_00b4: Invalid comparison between Unknown and I4
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Expected O, but got Unknown
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Expected O, but got Unknown
			//IL_0466: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04da: Expected O, but got Unknown
			//IL_06f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fb: Expected O, but got Unknown
			//IL_05c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cf: Expected O, but got Unknown
			//IL_065f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0666: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Invalid comparison between Unknown and I4
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Invalid comparison between Unknown and I4
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0563: Unknown result type (might be due to invalid IL or missing references)
			//IL_056a: Expected O, but got Unknown
			//IL_0717: Unknown result type (might be due to invalid IL or missing references)
			//IL_0725: Unknown result type (might be due to invalid IL or missing references)
			//IL_072c: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Invalid comparison between Unknown and I4
			//IL_0834: Unknown result type (might be due to invalid IL or missing references)
			//IL_083b: Expected O, but got Unknown
			//IL_062c: Unknown result type (might be due to invalid IL or missing references)
			//IL_074b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0752: Expected O, but got Unknown
			Packets val = (Packets)e.MessageId;
			Packet val2 = PacketFactory.PacketFromMessage(val, e.Message);
			if (val2 == null)
			{
				return;
			}
			PacketReceived?.Invoke(val, val2);
			if ((int)val <= 35)
			{
				switch (val - 1)
				{
				case 0:
				{
					ServerConnectionResponse val7 = (ServerConnectionResponse)val2;
					LocalID = val7.LocalClientId;
					TickRate = val7.TickRate;
					ServerState = val7.ServerState;
					_cachedLocalUser = val7.User;
					PlayerAnimation.ClientSendMode = val7.ClientAnimationSendMode;
					_handShook = true;
					ClientLogger.Log($"Received server handshake - our local ID is {val7.LocalClientId}, our UserKind is {val7.User.UserKind}.");
					if (val7.User.HasTag("elite"))
					{
						Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
						currentPlayer.SetCurrentMoveStyleEquipped((MoveStyle)2, true, true);
						SaveManager saveManager = Core.Instance.SaveManager;
						MPSkateboardSkin mPSkateboardSkin = MPUnlockManager.Instance.UnlockByID[Animator.StringToHash("goonieskateboard")] as MPSkateboardSkin;
						saveManager.CurrentSaveSlot.GetCharacterProgress(currentPlayer.character).moveStyleSkin = 0;
						saveManager.CurrentSaveSlot.GetCharacterProgress(currentPlayer.character).moveStyle = (MoveStyle)2;
						MPSaveData.Instance.GetCharacterData(currentPlayer.character).MPMoveStyleSkin = mPSkateboardSkin.Identifier;
						mPSkateboardSkin.ApplyToPlayer(currentPlayer);
						saveManager.SaveCurrentSaveSlot();
						SpecialSkinManager.Instance.ApplySpecialSkinToPlayer(currentPlayer, (SpecialSkins)2);
					}
					if (!SeenMOTD || val7.AlwaysShowMOTD)
					{
						SeenMOTD = true;
						if (!string.IsNullOrEmpty(val7.MOTD))
						{
							ChatUI.Instance.AddMessage(val7.MOTD);
						}
					}
					return;
				}
				case 1:
				{
					ServerClientStates val9 = (ServerClientStates)val2;
					foreach (KeyValuePair<ushort, ClientState> clientState in val9.ClientStates)
					{
						if (!Players.TryGetValue(clientState.Key, out var value7))
						{
							value7 = new MPPlayer();
							Players[clientState.Key] = value7;
						}
						value7.SetClientState(clientState.Value);
						value7.ClientId = clientState.Key;
						value7.UpdateClientStateVisuals();
						value7.UpdateNameplate();
					}
					if (val9.Full)
					{
						foreach (MPPlayer item in new List<MPPlayer>(Players.Values))
						{
							if (!val9.ClientStates.ContainsKey(item.ClientId))
							{
								OnClientDisconnected(this, item.ClientId);
							}
						}
					}
					ClientStatesUpdate?.Invoke();
					return;
				}
				case 3:
				{
					foreach (KeyValuePair<ushort, ClientVisualState> clientVisualState2 in ((ServerClientVisualStates)val2).ClientVisualStates)
					{
						if (Players.TryGetValue(clientVisualState2.Key, out var value5))
						{
							ClientVisualState clientVisualState = value5.ClientVisualState;
							value5.UpdateVisualState(clientVisualState2.Value);
							if (clientVisualState == null)
							{
								value5.UpdateClientStateVisuals();
							}
						}
					}
					return;
				}
				case 4:
				{
					PlayerAnimation val4 = (PlayerAnimation)val2;
					if (Players.TryGetValue(((PlayerPacket)val4).ClientId, out var value2) && (Object)(object)value2.Player != (Object)null)
					{
						int num = val4.NewAnim;
						if (val4.BoE)
						{
							int num2 = default(int);
							num = ((!BunchOfEmotesSupport.TryGetGameAnimationForCustomAnimationHash(num, ref num2)) ? ClientConstants.MissingAnimationHash : num2);
						}
						MPUtility.PlayAnimationOnMultiplayerPlayer(value2.Player, num, val4.ForceOverwrite, val4.Instant, val4.AtTime);
					}
					return;
				}
				case 5:
				{
					if (!MPSettings.Instance.PlayerAudioEnabled)
					{
						return;
					}
					PlayerVoice val6 = (PlayerVoice)val2;
					if (Players.TryGetValue(((PlayerPacket)val6).ClientId, out var value4) && (Object)(object)value4.Player != (Object)null && !value4.ShouldIgnore())
					{
						try
						{
							value4.Player.PlayVoice((AudioClipID)val6.AudioClipId, (VoicePriority)val6.VoicePriority, true);
							return;
						}
						catch (Exception)
						{
							return;
						}
					}
					return;
				}
				case 7:
				{
					PlayerGraffitiSlash val8 = (PlayerGraffitiSlash)val2;
					if (Players.TryGetValue(((PlayerPacket)val8).ClientId, out var value6) && (Object)(object)value6.Player != (Object)null && !value6.ShouldIgnore())
					{
						value6.Player.RemoveGraffitiSlash();
						value6.Player.CreateGraffitiSlashEffect(((Component)value6.Player).transform, val8.Direction.ToUnityVector3());
						value6.Player.AudioManager.PlaySfxGameplay((SfxCollectionID)13, (AudioClipID)10, value6.Player.playerOneShotAudioSource, 0f);
					}
					return;
				}
				case 8:
				{
					PlayerGraffitiFinisher val5 = (PlayerGraffitiFinisher)val2;
					if (Players.TryGetValue(((PlayerPacket)val5).ClientId, out var value3) && (Object)(object)value3.Player != (Object)null && !value3.ShouldIgnore())
					{
						value3.Player.RemoveGraffitiSlash();
						value3.Player.CreateGraffitiFinishEffect(((Component)value3.Player).transform, (GraffitiSize)val5.GraffitiSize);
						value3.Player.AudioManager.PlaySfxGameplay((SfxCollectionID)13, (AudioClipID)559, value3.Player.playerOneShotAudioSource, 0f);
					}
					return;
				}
				case 6:
				{
					PlayerGenericEvent val3 = (PlayerGenericEvent)val2;
					if (Players.TryGetValue(((PlayerPacket)val3).ClientId, out var value))
					{
						ExecuteGenericEvent(val3.Event, value);
					}
					return;
				}
				case 2:
					return;
				}
				if ((int)val != 24)
				{
					if ((int)val == 35 && GetLocalUser().IsModerator)
					{
						ServerBanList val10 = (ServerBanList)val2;
						string text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), "ACN");
						string text2 = Path.Combine(text, "banned_users.json");
						ChatUI instance = ChatUI.Instance;
						ClientLogger.Log("Received ban list from server. Will write to " + text2 + ".");
						try
						{
							Directory.CreateDirectory(text);
							File.WriteAllText(text2, val10.JsonData);
							instance.AddMessage("Ban list written to " + text2);
							return;
						}
						catch (Exception ex2)
						{
							instance.AddMessage("Failed to write ban list.");
							Debug.LogError((object)ex2);
							return;
						}
					}
				}
				else
				{
					ServerPlayerCount val11 = (ServerPlayerCount)val2;
					PlayerCountByStage = val11.PlayerCountByStage;
				}
				return;
			}
			switch (val - 39)
			{
			case 11:
			{
				ServerServerStateUpdate val18 = (ServerServerStateUpdate)(object)((val2 is ServerServerStateUpdate) ? val2 : null);
				ServerState = val18.State;
				return;
			}
			case 10:
			{
				ServerSetSpecialSkin val16 = (ServerSetSpecialSkin)(object)((val2 is ServerSetSpecialSkin) ? val2 : null);
				Player currentPlayer2 = WorldHandler.instance.GetCurrentPlayer();
				if ((int)val16.SpecialSkin == -1)
				{
					SpecialSkinManager.Instance.RemoveSpecialSkinFromPlayer(currentPlayer2);
					return;
				}
				SpecialSkinManager.Instance.ApplySpecialSkinToPlayer(currentPlayer2, val16.SpecialSkin);
				SpecialSkinManager.Instance.ApplyRandomVariantToPlayer(currentPlayer2);
				return;
			}
			case 1:
				LocalPlayerComponent.Chibi = ((ServerSetChibi)((val2 is ServerSetChibi) ? val2 : null)).Set;
				return;
			case 13:
			{
				ServerDamage val14 = (ServerDamage)(object)((val2 is ServerDamage) ? val2 : null);
				WorldHandler.instance.GetCurrentPlayer().ChangeHP(val14.Damage);
				return;
			}
			case 14:
			{
				ServerSetProp val17 = (ServerSetProp)(object)((val2 is ServerSetProp) ? val2 : null);
				if (val17.Disguised)
				{
					PlayerComponent.GetLocal().ApplyPropDisguise(val17.PropId);
				}
				else
				{
					PlayerComponent.GetLocal().RemovePropDisguise();
				}
				return;
			}
			case 0:
			{
				ClientHitByPlayer val15 = (ClientHitByPlayer)(object)((val2 is ClientHitByPlayer) ? val2 : null);
				if (((PlayerPacket)val15).ClientId != LocalID && val15.Attacker == LocalID)
				{
					MPSaveData.Instance.Stats.PlayersHit++;
					Core.Instance.SaveManager.SaveCurrentSaveSlot();
				}
				return;
			}
			case 9:
			{
				ServerClientDisconnected val13 = (ServerClientDisconnected)val2;
				if (Players.ContainsKey(val13.ClientId))
				{
					OnClientDisconnected(this, val13.ClientId);
					ClientStatesUpdate?.Invoke();
				}
				return;
			}
			case 12:
			{
				ServerTeleportPlayer val12 = (ServerTeleportPlayer)val2;
				MPUtility.PlaceCurrentPlayer(val12.Position.ToUnityVector3(), val12.Rotation.ToUnityQuaternion());
				return;
			}
			case 2:
			case 3:
			case 4:
			case 5:
			case 6:
			case 7:
			case 8:
				return;
			}
			if ((int)val != 62)
			{
				if ((int)val == 64)
				{
					ClientCustomPacket val19 = (ClientCustomPacket)val2;
					if (_customPacketHandlers.TryGetValue(val19.CustomPacketId, out var value8))
					{
						value8?.Invoke(val19.Sender, val19.Data);
					}
				}
			}
			else
			{
				SendAuth(((ServerChallenge)((val2 is ServerChallenge) ? val2 : null)).Challenge);
			}
		}

		[IteratorStateMachine(typeof(<AttemptReconnect>d__75))]
		private IEnumerator AttemptReconnect()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AttemptReconnect>d__75(0)
			{
				<>4__this = this
			};
		}

		private void OnConnectionFailed(object sender, ConnectionFailedEventArgs e)
		{
			ClientLogger.Log("Failed to connect to server. Reason: " + e.Reason);
			ClientLogger.Log("Will attempt to re-connect");
			((MonoBehaviour)this).StopAllCoroutines();
			((MonoBehaviour)this).StartCoroutine(AttemptReconnect());
		}

		private void OnDisconnect(object sender, DisconnectedEventArgs e)
		{
			ClientLogger.Log("Disconnected! Reason: " + e.Reason);
			ClientLogger.Log("Will attempt to re-connect");
			((MonoBehaviour)this).StopAllCoroutines();
			((MonoBehaviour)this).StartCoroutine(AttemptReconnect());
		}

		public void SendAuth(string challenge)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			if (!string.IsNullOrWhiteSpace(challenge) && challenge.Length >= 10)
			{
				ClientLogger.Log("Challenge received, sending auth...");
				string authKey = AuthKey;
				ClientState val = CreateClientState();
				ClientAuth val2 = new ClientAuth(AuthUser.HashPassword(authKey, challenge), val, SystemGuid.Value(), MPUtility.GetOrCreateSystemGUID());
				val2.Invisible = MPSettings.Instance.Invisible;
				SendPacket((Packet)(object)val2, (SendModes)1, (NetChannels)0);
			}
		}

		public ClientState CreateClientState()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected I4, but got Unknown
			//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_00b2: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			PlayerComponent localPlayerComponent = LocalPlayerComponent;
			ClientState val = new ClientState
			{
				Name = _mpSettings.PlayerName,
				CrewName = _mpSettings.CrewName,
				Character = (sbyte)currentPlayer.character,
				FallbackCharacter = (sbyte)MPSettings.Instance.FallbackCharacter,
				FallbackOutfit = (byte)MPSettings.Instance.FallbackOutfit,
				Outfit = (byte)Core.Instance.SaveManager.CurrentSaveSlot.GetCharacterProgress(currentPlayer.character).outfit
			};
			Scene activeScene = SceneManager.GetActiveScene();
			val.Stage = (int)Utility.SceneNameToStage(((Scene)(ref activeScene)).name);
			val.SpecialSkin = localPlayerComponent.SpecialSkin;
			val.SpecialSkinVariant = localPlayerComponent.SpecialSkinVariant;
			val.HasSpecialUnlock = MPSaveData.Instance.UnlockedGoonieBoard;
			val.ShowBadges = MPSettings.Instance.ShowBadges;
			ClientState val2 = val;
			if (CrewBoomSupport.Installed)
			{
				val2.CrewBoomCharacter = CrewBoomSupport.GetGuidForCharacter(currentPlayer.character);
				if (localPlayerComponent.StreamedCharacterHandle != null)
				{
					val2.CrewBoomCharacter = localPlayerComponent.StreamedCharacterHandle.GUID;
					val2.Outfit = (byte)localPlayerComponent.StreamedOutfit;
				}
			}
			return val2;
		}

		public void SendClientState()
		{
			SendPacket((Packet)(object)CreateClientState(), (SendModes)1, (NetChannels)2);
			InfrequentClientStateUpdateQueued = false;
		}

		private void OnConnected(object sender, EventArgs e)
		{
			ClientLogger.Log("Connected!");
		}

		private void OnDestroy()
		{
			Disconnect();
			ClientLobbyManager.LobbiesUpdated = (Action)Delegate.Remove(ClientLobbyManager.LobbiesUpdated, new Action(OnLobbiesUpdated));
			ClientLobbyManager?.Dispose();
		}
	}
	public class ClientLobbyManager : IDisposable
	{
		public static Action LobbiesUpdated;

		public static Action LobbyChanged;

		public static Action LobbySoftUpdated;

		public Dictionary<uint, Lobby> Lobbies = new Dictionary<uint, Lobby>();

		public List<uint> LobbiesInvited = new List<uint>();

		private ClientController _clientController;

		private WorldHandler _worldHandler;

		public uint QueuedLobby;

		public Lobby CurrentLobby { get; private set; }

		public void QueueJoinLobby(uint lobbyId)
		{
			QueuedLobby = lobbyId;
		}

		public ClientLobbyManager()
		{
			_clientController = ClientController.Instance;
			ClientController.PacketReceived = (Action<Packets, Packet>)Delegate.Combine(ClientController.PacketReceived, new Action<Packets, Packet>(OnPacketReceived));
			ClientController.ServerDisconnect = (Action)Delegate.Combine(ClientController.ServerDisconnect, new Action(OnDisconnect));
			_worldHandler = WorldHandler.instance;
			LobbyChanged = (Action)Delegate.Combine(LobbyChanged, new Action(HandleEncounter));
		}

		public void Dispose()
		{
			ClientController.PacketReceived = (Action<Packets, Packet>)Delegate.Remove(ClientController.PacketReceived, new Action<Packets, Packet>(OnPacketReceived));
			ClientController.ServerDisconnect = (Action)Delegate.Remove(ClientController.ServerDisconnect, new Action(OnDisconnect));
			if (CurrentLobby != null && CurrentLobby.InGame)
			{
				CurrentLobby.CurrentGamemode.OnEnd(cancelled: true);
			}
			if ((Object)(object)_worldHandler.currentEncounter != (Object)null && _worldHandler.currentEncounter is ProxyEncounter)
			{
				_worldHandler.currentEncounter.SetEncounterState((EncounterState)0);
			}
			LobbyChanged = (Action)Delegate.Remove(LobbyChanged, new Action(HandleEncounter));
		}

		private void HandleEncounter()
		{
			if (CurrentLobby == null && (Object)(object)_worldHandler.currentEncounter != (Object)null && _worldHandler.currentEncounter is ProxyEncounter)
			{
				_worldHandler.currentEncounter.SetEncounterState((EncounterState)0);
			}
			else if (CurrentLobby != null && (Object)(object)_worldHandler.currentEncounter == (Object)null)
			{
				((Encounter)ProxyEncounter.Instance).ActivateEncounter();
			}
		}

		public void OnUpdate()
		{
			if (CurrentLobby != null && CurrentLobby.InGame)
			{
				CurrentLobby.CurrentGamemode.OnUpdate_InGame();
			}
			if (QueuedLobby != 0 && Lobbies.TryGetValue(QueuedLobby, out var value) && !value.LobbyState.InGame && CanJoinLobby())
			{
				JoinLobby(QueuedLobby);
			}
		}

		public bool CanJoinLobby()
		{
			if ((Object)(object)_worldHandler.currentEncounter != (Object)null && !(_worldHandler.currentEncounter is ProxyEncounter))
			{
				return false;
			}
			return true;
		}

		public void OnTick()
		{
			if (CurrentLobby != null && CurrentLobby.InGame)
			{
				CurrentLobby.CurrentGamemode.OnTick_InGame();
			}
		}

		public string GetLobbyName(uint lobbyId)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			return GamemodeFactory.GetGamemodeName(Lobbies[lobbyId].LobbyState.Gamemode);
		}

		public void CreateLobby(GamemodeIDs gamemode, GamemodeSettings settings)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			if (!CanJoinLobby())
			{
				return;
			}
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				using BinaryWriter writer = new BinaryWriter(memoryStream);
				settings.Write(writer);
				array = memoryStream.ToArray();
			}
			_clientController.SendPacket((Packet)new ClientLobbyCreate(gamemode, array), (SendModes)2, (NetChannels)2);
		}

		public void JoinLobby(uint lobbyId)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			if (CanJoinLobby())
			{
				QueueJoinLobby(0u);
				_clientController.SendPacket((Packet)new ClientLobbyJoin(lobbyId), (SendModes)2, (NetChannels)2);
				NotificationController.Instance.RemoveNotificationForLobby(lobbyId);
			}
		}

		public void LeaveLobby()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			_clientController.SendPacket((Packet)new ClientLobbyLeave(), (SendModes)2, (NetChannels)2);
		}

		public void StartGame()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			_clientController.SendPacket((Packet)new ClientLobbyStart(), (SendModes)2, (NetChannels)2);
		}

		public void ResetWins()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			_clientController.SendPacket((Packet)new ClientLobbyResetWins(), (SendModes)2, (NetChannels)2);
		}

		public void EndGame()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			_clientController.SendPacket((Packet)new ClientLobbyEnd(), (SendModes)2, (NetChannels)2);
		}

		public void SetChallenge(bool set)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			_clientController.SendPacket((Packet)new ClientLobbySetChallenge(set), (SendModes)2, (NetChannels)2);
		}

		public void SetAllowTeamSwitching(bool set)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			_clientController.SendPacket((Packet)new ClientLobbySetAllowTeamSwitching(set), (SendModes)2, (NetChannels)2);
		}

		public void SetGamemode(GamemodeIDs gamemode, GamemodeSettings settings)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			byte[] array;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				using BinaryWriter writer = new BinaryWriter(memoryStream);
				settings.Write(writer);
				array = memoryStream.ToArray();
			}
			_clientController.SendPacket((Packet)new ClientLobbySetGamemode(gamemode, array), (SendModes)2, (NetChannels)2);
		}

		public void InvitePlayer(ushort playerId)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			_clientController.SendPacket((Packet)new ClientLobbyInvite(playerId), (SendModes)2, (NetChannels)2);
		}

		public void DeclineInvite(uint lobbyId)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			_clientController.SendPacket((Packet)new ClientLobbyDeclineInvite(lobbyId), (SendModes)2, (NetChannels)2);
			NotificationController.Instance.RemoveNotificationForLobby(lobbyId);
		}

		public void DeclineAllInvites()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			_clientController.SendPacket((Packet)new ClientLobbyDeclineAllInvites(), (SendModes)2, (NetChannels)2);
			NotificationController.Instance.RemoveAllNotifications();
		}

		public void KickPlayer(ushort playerId)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			_clientController.SendPacket((Packet)new ClientLobbyKick(playerId), (SendModes)2, (NetChannels)2);
		}

		private void OnPacketReceived(Packets packetId, Packet packet)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected I4, but got Unknown
			//IL_008b: 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_0058: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Invalid comparison between Unknown and I4
			//IL_0020: 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_0121: Expected O, but got Unknown
			if (CurrentLobby != null && CurrentLobby.InGame)
			{
				CurrentLobby.CurrentGamemode.OnPacketReceived_InGame(packetId, packet);
			}
			switch (packetId - 13)
			{
			case 2:
			{
				ServerLobbyDeleted val2 = (ServerLobbyDeleted)packet;
				if (Lobbies.TryGetValue(val2.LobbyUID, out var value2))
				{
					Lobbies.Remove(val2.LobbyUID);
					OnLobbyDeleted(value2);
				}
				return;
			}
			case 0:
				foreach (LobbyState lobby in ((ServerLobbies)packet).Lobbies)
				{
					if (!Lobbies.TryGetValue(lobby.Id, out var value))
					{
						value = new Lobby();
						Lobbies[lobby.Id] = value;
					}
					value.LobbyState = lobby;
				}
				OnLobbiesUpdated();
				return;
			case 4:
				OnStartGame();
				return;
			case 5:
			{
				ServerLobbyEnd val = (ServerLobbyEnd)packet;
				OnEndGame(val.Cancelled);
				return;
			}
			case 1:
			case 3:
				return;
			}
			if ((int)packetId == 47)
			{
				ServerLobbySoftUpdate val3 = (ServerLobbySoftUpdate)packet;
				if (CurrentLobby == null)
				{
					UpdateCurrentLobby();
				}
				if (CurrentLobby.LobbyState.Players.TryGetValue(val3.PlayerId, out var value3))
				{
					value3.Score = val3.Score;
				}
				OnLobbySoftUpdated();
			}
		}

		private void OnDisconnect()
		{
			QueueJoinLobby(0u);
			Lobbies.Clear();
			OnLobbiesUpdated();
		}

		private void UpdateCurrentLobby()
		{
			CurrentLobby = null;
			foreach (KeyValuePair<uint, Lobby> lobby in Lobbies)
			{
				if (lobby.Value.LobbyState.Players.Keys.Contains(_clientController.LocalID))
				{
					CurrentLobby = lobby.Value;
				}
			}
		}

		private void OnEndGame(bool cancelled)
		{
			if (CurrentLobby != null)
			{
				if (CurrentLobby.InGame)
				{
					CurrentLobby.CurrentGamemode.OnEnd(cancelled);
				}
				CurrentLobby.CurrentGamemode = null;
				CurrentLobby.LobbyState.InGame = false;
			}
		}

		private void OnStartGame()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (CurrentLobby == null)
			{
				UpdateCurrentLobby();
			}
			if (CurrentLobby.InGame)
			{
				CurrentLobby.CurrentGamemode.OnEnd(cancelled: true);
			}
			CurrentLobby.CurrentGamemode = GamemodeFactory.GetGamemode(CurrentLobby.LobbyState.Gamemode);
			CurrentLobby.CurrentGamemode.Lobby = CurrentLobby;
			CurrentLobby.LobbyState.InGame = true;
			CurrentLobby.CurrentGamemode.OnStart();
			Player currentPlayer = _worldHandler.GetCurrentPlayer();
			PhoneUtility.BackToHomescreen(currentPlayer.phone);
			currentPlayer.phone.TurnOff(false);
		}

		private void OnLobbyDeleted(Lobby lobby)
		{
			if (QueuedLobby != 0 && lobby.LobbyState.Id == QueuedLobby)
			{
				QueueJoinLobby(0u);
			}
			if (lobby == CurrentLobby)
			{
				CurrentLobby = null;
				if (lobby.InGame)
				{
					lobby.CurrentGamemode.OnEnd(cancelled: true);
				}
				LobbyChanged?.Invoke();
			}
			UpdateCurrentLobby();
			LobbiesUpdated?.Invoke();
		}

		private void OnLobbySoftUpdated()
		{
			LobbySoftUpdated?.Invoke();
		}

		private void OnLobbiesUpdated()
		{
			Lobby currentLobby = CurrentLobby;
			UpdateCurrentLobby();
			LobbiesInvited.Clear();
			foreach (KeyValuePair<uint, Lobby> lobby in Lobbies)
			{
				if (lobby.Value != CurrentLobby && lobby.Value.LobbyState.InvitedPlayers.Keys.Contains(_clientController.LocalID))
				{
					LobbiesInvited.Add(lobby.Key);
				}
			}
			if (currentLobby != CurrentLobby)
			{
				if (currentLobby != null && currentLobby.InGame)
				{
					currentLobby.CurrentGamemode.OnEnd(cancelled: true);
					currentLobby.CurrentGamemode = null;
				}
				LobbyChanged?.Invoke();
			}
			LobbiesUpdated?.Invoke();
		}
	}
	public static class ClientLogger
	{
		public static void Log(string message)
		{
			Debug.Log((object)("[" + DateTime.Now.ToShortTimeString() + "] " + message));
		}
	}
	public class DeathSequenceController : MonoBehaviour
	{
		private Player _player;

		private Camera _cam;

		private float _timer;

		private const float SpinSpeed = 4f;

		private const float MoveSpeed = 0.1f;

		private const float HeadOffset = 0.4f;

		private bool _wasMusicPlaying;

		private AudioSource _musicSource;

		public static DeathSequenceController Instance { get; private set; }

		private void Awake()
		{
			_musicSource = ((Component)this).gameObject.AddComponent<AudioSource>();
			MPAssets instance = MPAssets.Instance;
			_musicSource.clip = instance.DeathMusic[Random.RandomRangeInt(0, instance.DeathMusic.Length)];
			_musicSource.spatialBlend = 0f;
			_musicSource.loop = false;
			_musicSource.volume = Core.Instance.audioManager.MusicVolume;
			_musicSource.Play();
			Instance = this;
			WorldHandler instance2 = WorldHandler.instance;
			_player = instance2.GetCurrentPlayer();
			_cam = instance2.CurrentCamera;
			if (NetRadioSupport.Installed)
			{
				NetRadioSupport.Paused = true;
			}
			IMusicPlayer musicPlayer = Core.Instance.AudioManager.MusicPlayer;
			_wasMusicPlaying = musicPlayer.IsPlaying;
			musicPlayer.Pause();
		}

		private void LateUpdate()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			((Component)_cam).transform.position = _player.headTf.position + 0.4f * Vector3.up + _timer * 0.1f * Vector3.up;
			Quaternion rotation = Quaternion.LookRotation(Vector3.down, ((Component)_player).transform.forward) * Quaternion.Euler(0f, 0f, _timer * 4f);
			((Component)_cam).transform.rotation = rotation;
			_timer += Time.deltaTime;
		}

		private void OnDestroy()
		{
			Instance = null;
		}

		public void End()
		{
			if (NetRadioSupport.Installed)
			{
				NetRadioSupport.Paused = false;
			}
			IMusicPlayer musicPlayer = Core.Instance.AudioManager.MusicPlayer;
			if (_wasMusicPlaying)
			{
				musicPlayer.Play();
			}
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		public static void Create()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new GameObject("Death Sequence Controller").AddComponent<DeathSequenceController>();
		}
	}
	public class DebugUI : MonoBehaviour
	{
		internal static DebugUI Instance;

		private TextMeshProUGUI _curAnimLabel;

		private void Awake()
		{
			Instance = this;
			Init();
		}

		private static TextMeshProUGUI MakeLabel(TextMeshProUGUI reference, string name)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			TMP_FontAsset font = ((TMP_Text)reference).font;
			float fontSize = ((TMP_Text)reference).fontSize;
			Material fontMaterial = ((TMP_Text)reference).fontMaterial;
			TextMeshProUGUI obj = new GameObject(name).AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj).font = font;
			((TMP_Text)obj).fontSize = fontSize;
			((TMP_Text)obj).fontMaterial = fontMaterial;
			((TMP_Text)obj).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)obj).fontStyle = (FontStyles)1;
			((TMP_Text)obj).outlineWidth = 0.2f;
			return obj;
		}

		private static TextMeshProUGUI MakeGlyph(TextMeshProUGUI reference, int actionID)
		{
			TextMeshProUGUI val = MakeLabel(reference, "");
			((Component)val).gameObject.SetActive(false);
			UIButtonGlyphComponent obj = ((Component)val).gameObject.AddComponent<UIButtonGlyphComponent>();
			obj.inputActionID = actionID;
			obj.localizedGlyphTextComponent = val;
			obj.localizedTextComponent = val;
			((Behaviour)obj).enabled = true;
			((Component)val).gameObject.SetActive(true);
			return val;
		}

		private void Init()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = ((Component)Instance).gameObject.AddComponent<RectTransform>();
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			TextMeshProUGUI[] componentsInChildren = ((Component)Core.Instance.UIManager.danceAbilityUI).GetComponentsInChildren<TextMeshProUGUI>(true);
			TextMeshProUGUI val2 = null;
			TextMeshProUGUI[] array = componentsInChildren;
			foreach (TextMeshProUGUI val3 in array)
			{
				if (((Object)((Component)((TMP_Text)val3).transform).gameObject).name == "DanceSelectConfirmText")
				{
					val2 = val3;
				}
			}
			if (!((Object)(object)val2 == (Object)null))
			{
				float num = 100f;
				float num2 = -50f;
				float num3 = 50f;
				float num4 = 75f;
				_curAnimLabel = MakeLabel(val2, "CurAnim");
				((TMP_Text)_curAnimLabel).text = "CurAnim";
				((TMP_Text)_curAnimLabel).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_curAnimLabel).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_curAnimLabel).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_curAnimLabel).rectTransform.anchoredPosition = new Vector2(num + num4, num3 + num2);
				((Transform)((TMP_Text)_curAnimLabel).rectTransform).SetParent((Transform)(object)val, false);
			}
		}

		private void Update()
		{
			if ((Object)(object)_curAnimLabel == (Object)null)
			{
				return;
			}
			WorldHandler instance = WorldHandler.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				Player currentPlayer = instance.GetCurrentPlayer();
				if (!((Object)(object)currentPlayer == (Object)null))
				{
					((TMP_Text)_curAnimLabel).text = $"CurAnim: {currentPlayer.curAnim}\n";
					TextMeshProUGUI curAnimLabel = _curAnimLabel;
					((TMP_Text)curAnimLabel).text = ((TMP_Text)curAnimLabel).text + $"Players: {RenderStats.Players}\n";
					TextMeshProUGUI curAnimLabel2 = _curAnimLabel;
					((TMP_Text)curAnimLabel2).text = ((TMP_Text)curAnimLabel2).text + $"Players Rendered (High): {RenderStats.PlayersRendered}\n";
					TextMeshProUGUI curAnimLabel3 = _curAnimLabel;
					((TMP_Text)curAnimLabel3).text = ((TMP_Text)curAnimLabel3).text + $"Players Rendered (Low): {RenderStats.PlayersRenderedLOD}\n";
					TextMeshProUGUI curAnimLabel4 = _curAnimLabel;
					((TMP_Text)curAnimLabel4).text = ((TMP_Text)curAnimLabel4).text + $"Players Culled: {RenderStats.PlayersCulled}\n";
					TextMeshProUGUI curAnimLabel5 = _curAnimLabel;
					((TMP_Text)curAnimLabel5).text = ((TMP_Text)curAnimLabel5).text + $"Loaded Characters: {CrewBoomStreamer.LoadedCharacters}\n";
				}
			}
		}

		public static void Create()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			GameObject val = new GameObject("Debug UI");
			val.transform.SetParent((Transform)(object)((Component)((Component)Core.Instance.UIManager.gameplay).transform.parent).GetComponent<RectTransform>(), false);
			val.AddComponent<DebugUI>();
		}
	}
	public class Emojis
	{
		public Dictionary<string, int> Sprites = new Dictionary<string, int>
		{
			{ ":car:", 25 },
			{ ":akkowot:", 24 },
			{ ":krehs:", 109 },
			{ ":ben:", 38 },
			{ ":skull:", 34 },
			{ ":pensive:", 46 },
			{ ":joy:", 47 },
			{ ":trans:", 48 },
			{ ":pride:", 49 },
			{ ":heart:", 50 },
			{ ":moke:", 69 },
			{ ":doro:", 39 },
			{ ":calm:", 74 },
			{ ":creature:", 75 },
			{ ":genshin:", 43 },
			{ ":squidward:", 45 },
			{ ":moke2:", 76 },
			{ ":nothinglikeyall:", 12 },
			{ ":gok:", 78 },
			{ ":remuza:", 80 },
			{ ":screamcat:", 21 },
			{ ":beegyoshigangsta:", 23 },
			{ ":marx:", 82 },
			{ ":raymundojacuveiandmariaquerisame:", 83 },
			{ ":sob:", 26 },
			{ ":tetobread:", 27 },
			{ ":fire:", 70 },
			{ ":bossup:", 84 },
			{ ":golshi:", 85 },
			{ ":iheardspidermanwasthere:", 86 },
			{ ":cleep:", 87 },
			{ ":flexup:", 88 },
			{ ":fentbob:", 89 },
			{ ":reimublink:", 90 },
			{ ":dojasword:", 91 },
			{ ":imready:", 92 },
			{ ":zaweegee:", 93 },
			{ ":zario:", 94 },
			{ ":konatathink:", 95 },
			{ ":wata:", 96 },
			{ ":guh:", 97 },
			{ ":grilla:", 98 },
			{ ":mokethink:", 72 },
			{ ":benmoke:", 99 },
			{ ":dojasob:", 100 },
			{ ":autoleft:", 101 },
			{ ":autoright:", 102 },
			{ ":itsfumover:", 103 },
			{ ":steamhappy:", 104 },
			{ ":happysprite:", 106 },
			{ ":tails:", 110 },
			{ ":onmaria:", 113 },
			{ ":pride2:", 115 }
		};
	}
	public static class InputUtils
	{
		public static bool Override;

		public static bool InputBlocked
		{
			get
			{
				if (Override)
				{
					return false;
				}
				ChatUI instance = ChatUI.Instance;
				PlayerListUI instance2 = PlayerListUI.Instance;
				if ((Object)(object)instance2 == (Object)null)
				{
					return false;
				}
				if ((Object)(object)instance == (Object)null)
				{
					return false;
				}
				if (instance.State != ChatUI.States.Focused)
				{
					return instance2.Displaying;
				}
				return true;
			}
		}
	}
	public class Lobby
	{
		public LobbyState LobbyState;

		public Gamemode CurrentGamemode;

		public bool InGame
		{
			get
			{
				if (CurrentGamemode != null)
				{
					return CurrentGamemode.InGame;
				}
				return false;
			}
		}

		public LobbyPlayer GetHighestScoringPlayer()
		{
			LobbyPlayer val = null;
			foreach (KeyValuePair<ushort, LobbyPlayer> player in LobbyState.Players)
			{
				if (val == null || player.Value.Score > val.Score)
				{
					val = player.Value;
				}
			}
			return val;
		}

		public Gamemode GetOrCreateGamemode()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (CurrentGamemode != null)
			{
				return CurrentGamemode;
			}
			return GamemodeFactory.GetGamemode(LobbyState.Gamemode);
		}
	}
	public class LobbyPlayerUI : MonoBehaviour
	{
		private TextMeshProUGUI _playerName;

		private TextMeshProUGUI _score;

		private ClientController _clientController;

		private LobbyPlayer _lobbyPlayer;

		private Lobby _lobby;

		private GameObject _readySprite;

		private GameObject _notReadySprite;

		private GameObject _afkSprite;

		private Image _bg;

		private Image _teamBg;

		public int Position = -1;

		private const float TeamPlayerDarkening = 0.25f;

		private void Awake()
		{
			_playerName = ((Component)((Component)this).transform.Find("Label")).GetComponent<TextMeshProUGUI>();
			_score = ((Component)((Component)this).transform.Find("Score")).GetComponent<TextMeshProUGUI>();
			_readySprite = ((Component)((Component)this).transform.Find("Ready")).gameObject;
			_notReadySprite = ((Component)((Component)this).transform.Find("Not Ready")).gameObject;
			_afkSprite = ((Component)((Component)this).transform.Find("AFK")).gameObject;
			_bg = ((Component)((Component)this).transform.Find("BG")).GetComponent<Image>();
			_teamBg = ((Component)((Component)this).transform.Find("Team BG")).GetComponent<Image>();
			_clientController = ClientController.Instance;
			((TMP_Text)_playerName).spriteAsset = MPAssets.Instance.Sprites;
		}

		private void Update()
		{
			if (_lobbyPlayer == null || !_clientController.Players.TryGetValue(_lobbyPlayer.Id, out var value))
			{
				return;
			}
			ClientVisualState clientVisualState = value.ClientVisualState;
			if (clientVisualState != null)
			{
				_afkSprite.SetActive(clientVisualState.AFK);
				if (!_lobby.InGame)
				{
					_readySprite.SetActive(_lobbyPlayer.Ready);
					_notReadySprite.SetActive(!_lobbyPlayer.Ready);
				}
				else
				{
					_readySprite.SetActive(false);
					_notReadySprite.SetActive(false);
				}
				if (_lobby.LobbyState.HostId == _lobbyPlayer.Id)
				{
					_readySprite.SetActive(false);
					_notReadySprite.SetActive(false);
				}
			}
		}

		private string FormatScore(float score)
		{
			if (score <= 0f)
			{
				return "0";
			}
			return FormattingUtility.FormatPlayerScore(CultureInfo.CurrentCulture, score);
		}

		public void SetTeam(Lobby lobby, Team team, byte teamId, int standing)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			_lobby = lobby;
			string text = MPUtility.GetCrewDisplayName(MPUtility.GetTeamName(lobby.LobbyState, team, teamId));
			if (string.IsNullOrWhiteSpace(text))
			{
				text = team.Name;
			}
			_lobbyPlayer = null;
			((TMP_Text)_playerName).text = $"{standing}. {text}";
			((Component)_bg).gameObject.SetActive(false);
			_readySprite.SetActive(false);
			_notReadySprite.SetActive(false);
			((Component)_teamBg).gameObject.SetActive(true);
			_afkSprite.gameObject.SetActive(false);
			((Graphic)_teamBg).color = new Color(team.Color.r, team.Color.g, team.Color.b, Theme.CurrentTheme.LobbyPlayerTeamBackgroundAlpha);
			((TMP_Text)_score).text = FormatScore(_lobby.LobbyState.GetScoreForTeam(teamId));
		}

		public void SetPlayer(LobbyPlayer player, Team team)
		{
			//IL_0088: 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_0145: Unknown result type (might be due to invalid IL or missing references)
			((Component)_bg).gameObject.SetActive(false);
			((Component)_teamBg).gameObject.SetActive(false);
			if (team == null)
			{
				((Component)_bg).gameObject.SetActive(true);
			}
			else
			{
				((Component)_teamBg).gameObject.SetActive(true);
				((Graphic)_teamBg).color = new Color(team.Color.r * 0.25f, team.Color.g * 0.25f, team.Color.b * 0.25f, ((Graphic)_teamBg).color.a);
			}
			if (_clientController.ClientLobbyManager.Lobbies.TryGetValue(player.LobbyId, out var value))
			{
				_lobby = value;
				string text = MPUtility.GetPlayerDisplayName(_clientController.Players[player.Id].ClientState);
				if (value.LobbyState.HostId == player.Id)
				{
					text = "<color=yellow>[Host]</color> " + text;
				}
				_lobbyPlayer = player;
				((TMP_Text)_playerName).text = text;
				((TMP_Text)_score).text = FormatScore(_lobbyPlayer.Score);
				if (!value.LobbyState.InGame && GamemodeFactory.HasWins(value.LobbyState.Gamemode))
				{
					TextMeshProUGUI score = _score;
					((TMP_Text)score).text = ((TMP_Text)score).text + $" ({player.Wins})";
				}
				if (Position != -1 && team == null)
				{
					((TMP_Text)_playerName).text = $"{Position + 1}. {text}";
				}
			}
		}

		public static LobbyPlayerUI Create(GameObject reference)
		{
			GameObject obj = Object.Instantiate<GameObject>(reference);
			obj.SetActive(true);
			return obj.AddComponent<LobbyPlayerUI>();
		}
	}
	public class LobbyUI : MonoBehaviour
	{
		private GameObject _canvas;

		private TextMeshProUGUI _lobbyName;

		private ClientLobbyManager _lobbyManager;

		private GameObject _playerName;

		private float _playerNameHeight = 35f;

		private const int PlayerUIPoolSize = 32;

		private LobbyPlayerUI[] _playerUIs = new LobbyPlayerUI[32];

		private TextMeshProUGUI _lobbySettings;

		private bool _updateQueued;

		private bool _softUpdateQueued;

		private const float SoftUpdateRate = 0.5f;

		private float _softUpdateTimer;

		public static LobbyUI Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			_canvas = ((Component)((Component)this).transform.Find("Canvas")).gameObject;
			_lobbySettings = ((Component)_canvas.transform.Find("Lobby Settings")).GetComponent<TextMeshProUGUI>();
			_lobbyName = ((Component)_canvas.transform.Find("Lobby Name")).GetComponent<TextMeshProUGUI>();
			_lobbyManager = ClientController.Instance.ClientLobbyManager;
			ClientLobbyManager.LobbiesUpdated = (Action)Delegate.Combine(ClientLobbyManager.LobbiesUpdated, new Action(OnLobbiesUpdated));
			ClientLobbyManager.LobbySoftUpdated = (Action)Delegate.Combine(ClientLobbyManager.LobbySoftUpdated, new Action(OnLobbySoftUpdated));
			ClientController.ClientStatesUpdate = (Action)Delegate.Combine(ClientController.ClientStatesUpdate, new Action(OnLobbiesUpdated));
			_playerName = ((Component)_canvas.transform.Find("Player Name")).gameObject;
			_playerName.SetActive(false);
			InitializePlayerUIPool();
			Deactivate();
		}

		private void Update()
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got Unknown
			ClientController instance = ClientController.Instance;
			Lobby currentLobby = _lobbyManager.CurrentLobby;
			_softUpdateTimer += Time.deltaTime;
			if (_updateQueued)
			{
				_softUpdateQueued = false;
				_updateQueued = false;
				if (currentLobby == null)
				{
					Deactivate();
				}
				else
				{
					Activate();
				}
			}
			if (_softUpdateQueued && _softUpdateTimer >= 0.5f)
			{
				_softUpdateQueued = false;
				UpdatePlayerListing();
			}
			if (_softUpdateTimer >= 0.5f)
			{
				_softUpdateTimer = 0f;
			}
			if (currentLobby != null && !currentLobby.InGame && currentLobby.LobbyState.HostId != instance.LocalID)
			{
				PlayerControllerMapIDCollection allCurrentEnabledControllerMapCategoryIDs = Core.Instance.GameInput.GetAllCurrentEnabledControllerMapCategoryIDs(0);
				if (allCurrentEnabledControllerMapCategoryIDs.controllerMapCategoryIDs.Contains(0) && allCurrentEnabledControllerMapCategoryIDs.controllerMapCategoryIDs.Contains(6) && !Core.Instance.IsCorePaused && !MPUtility.AnyMenusOpen() && Input.GetKeyDown(MPSettings.Instance.ReadyKey))
				{
					instance.SendPacket((Packet)new ClientLobbySetReady(!currentLobby.LobbyState.Players[instance.LocalID].Ready), (SendModes)2, (NetChannels)2);
				}
			}
		}

		private void OnDestroy()
		{
			ClientLobbyManager.LobbiesUpdated = (Action)Delegate.Remove(ClientLobbyManager.LobbiesUpdated, new Action(OnLobbiesUpdated));
			ClientLobbyManager.LobbySoftUpdated = (Action)Delegate.Remove(ClientLobbyManager.LobbySoftUpdated, new Action(OnLobbySoftUpdated));
			ClientController.ClientStatesUpdate = (Action)Delegate.Remove(ClientController.ClientStatesUpdate, new Action(OnLobbiesUpdated));
		}

		private void InitializePlayerUIPool()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < 32; i++)
			{
				LobbyPlayerUI lobbyPlayerUI = LobbyPlayerUI.Create(_playerName);
				((Component)lobbyPlayerUI).transform.SetParent(_canvas.transform, false);
				Transform transform = ((Component)lobbyPlayerUI).transform;
				transform.localPosition -= new Vector3(0f, (float)(i + 1) * _playerNameHeight, 0f);
				lobbyPlayerUI.Position = i;
				_playerUIs[i] = lobbyPlayerUI;
				((Component)lobbyPlayerUI).gameObject.SetActive(false);
			}
		}

		private void OnLobbiesUpdated()
		{
			_updateQueued = true;
		}

		private void OnLobbySoftUpdated()
		{
			_softUpdateQueued = true;
		}

		private void Activate()
		{
			_canvas.SetActive(true);
			UpdateUI();
		}

		private void UpdatePlayerListing()
		{
			//IL_00eb: 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)
			Lobby lobby = _lobbyManager.CurrentLobby;
			if (lobby == null)
			{
				return;
			}
			LobbyPlayer[] array = lobby.LobbyState.Players.Values.OrderByDescending((LobbyPlayer p) => p.Score).ToArray();
			if (!lobby.LobbyState.InGame && GamemodeFactory.HasWins(lobby.LobbyState.Gamemode) && MPSettings.Instance.GamemodePlayerSort == Gamemode.PlayerSort.Wins)
			{
				array = lobby.LobbyState.Players.Values.OrderByDescending((LobbyPlayer p) => p.Wins).ToArray();
			}
			Gamemode orCreateGamemode = lobby.GetOrCreateGamemode();
			Team[] teams = GamemodeFactory.GetTeams(lobby.LobbyState.Gamemode);
			if (orCreateGamemode.TeamBased)
			{
				byte[] teamOrder = new byte[teams.Length];
				for (int i = 0; i < teams.Length; i++)
				{
					teamOrder[i] = (byte)i;
				}
				teamOrder = teamOrder.OrderByDescending((byte t) => lobby.LobbyState.GetScoreForTeam(t)).ToArray();
				array = array.OrderBy((LobbyPlayer p) => Array.IndexOf(teamOrder, p.Team)).ToArray();
			}
			int num = 1;
			int num2 = -1;
			int num3 = 0;
			for (int j = 0; j < 32; j++)
			{
				LobbyPlayerUI lobbyPlayerUI = _playerUIs[j];
				if (num3 >= array.Length)
				{
					if (((Component)lobbyPlayerUI).gameObject.activeSelf)
					{
						((Component)lobbyPlayerUI).gameObject.SetActive(false);
					}
					continue;
				}
				LobbyPlayer val = array[num3];
				Team team = null;
				if (orCreateGamemode.TeamBased)
				{
					team = teams[val.Team];
				}
				if (val.Team != num2 && orCreateGamemode.TeamBased)
				{
					num2 = val.Team;
					if (!((Component)lobbyPlayerUI).gameObject.activeSelf)
					{
						((Component)lobbyPlayerUI).gameObject.SetActive(true);
					}
					lobbyPlayerUI.SetTeam(lobby, team, val.Team, num);
					num++;
				}
				else
				{
					num3++;
					if (!((Component)lobbyPlayerUI).gameObject.activeSelf)
					{
						((Component)lobbyPlayerUI).gameObject.SetActive(true);
					}
					lobbyPlayerUI.SetPlayer(val, team);
				}
			}
		}

		public void UpdateUI()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			Lobby currentLobby = _lobbyManager.CurrentLobby;
			if (currentLobby != null)
			{
				currentLobby.GetOrCreateGamemode();
				GamemodeSettings gamemodeSettings = null;
				gamemodeSettings = ((!currentLobby.InGame) ? GamemodeFactory.ParseGamemodeSettings(_lobbyManager.CurrentLobby.LobbyState.Gamemode, _lobbyManager.CurrentLobby.LobbyState.GamemodeSettings) : currentLobby.CurrentGamemode.Settings);
				((TMP_Text)_lobbySettings).text = gamemodeSettings.GetDisplayString(_lobbyManager.CurrentLobby.LobbyState.HostId == ClientController.Instance.LocalID, _lobbyManager.CurrentLobby.InGame);
				((TMP_Text)_lobbyName).text = _lobbyManager.GetLobbyName(_lobbyManager.CurrentLobby.LobbyState.Id);
				UpdatePlayerListing();
			}
		}

		private void Deactivate()
		{
			_canvas.SetActive(false);
		}

		public static void Create()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			GameObject obj = Object.Instantiate<GameObject>(MPAssets.Instance.Bundle.LoadAsset<GameObject>("Lobby UI"));
			obj.transform.SetParent(((Component)Core.Instance.UIManager).transform, false);
			obj.AddComponent<LobbyUI>();
		}
	}
	public enum MinimapOverrideModes
	{
		None,
		ForceOff,
		ForceOn
	}
	public class MPAssets
	{
		public AssetBundle Bundle;

		public TMP_SpriteAsset Sprites;

		public Emojis Emojis;

		public Material LODMaterial;

		public Material AimOutlineMaterial;

		public AudioClip[] DeathMusic;

		public GameObject XmasHideoutPrefab;

		public Texture2D XmasSky;

		public static MPAssets Instance { get; private set; }

		public MPAssets(string rootPath)
		{
			Instance = this;
			Bundle = AssetBundle.LoadFromFile(Path.Combine(rootPath, "assets"));
			Sprites = Bundle.LoadAsset<TMP_SpriteAsset>("badges");
			LODMaterial = Bundle.LoadAsset<Material>("LODMaterial");
			Emojis = JsonConvert.DeserializeObject<Emojis>(File.ReadAllText(Path.Combine(rootPath, "emojimap.json")));
			DeathMusic = (AudioClip[])(object)new AudioClip[2]
			{
				Bundle.LoadAsset<AudioClip>("badfinger"),
				Bundle.LoadAsset<AudioClip>("drs")
			};
			AimOutlineMaterial = Bundle.LoadAsset<Material>("Aim Outline Material");
			new BadgeMap(Sprites).ParseFromDirectory(Path.Combine(rootPath, "badgemap"), 32);
			if (MPUtility.IsChristmas())
			{
				XmasHideoutPrefab = Bundle.LoadAsset<GameObject>("XmasHideout");
				XmasSky = Bundle.LoadAsset<Texture2D>("NightSky");
			}
		}
	}
	public class MPBuiltInSkin : MPMoveStyleSkin
	{
		public const int InlineBuiltinId = 6969420;

		public const string InlineTransformName = "builtin_inlines";

		public const int BikeBuiltinId = 6767420;

		public const string BikeBuiltinTransformName = "builtin_bmx";

		public const int SkateBuiltinId = 5318008;

		public const string SkateTransformName = "builtin_skate";

		private MoveStyle _moveStyle;

		public override MoveStyle MoveStyle => _moveStyle;

		public MPBuiltInSkin(MoveStyle moveStyle, int id)
			: base("Signature", "Use the character's unique gear.", id, unlockedByDefault: true, null, null)
		{
			//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)
			_moveStyle = moveStyle;
		}

		public override void ApplyToPlayer(Player player)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected I4, but got Unknown
			base.ApplyToPlayer(player);
			PlayerComponent playerComponent = PlayerComponent.Get(player);
			MoveStyle moveStyle = _moveStyle;
			switch (moveStyle - 1)
			{
			case 2:
				if ((Object)(object)playerComponent != (Object)null && playerComponent.HasCustomInlines)
				{
					player.characterVisual.moveStyleProps.skateL.GetComponent<MeshFilter>().sharedMesh = null;
					player.characterVisual.moveStyleProps.skateR.GetComponent<MeshFilter>().sharedMesh = null;
				}
				break;
			case 1:
				if ((Object)(object)playerComponent != (Object)null && playerComponent.HasCustomSkateboard)
				{
					player.characterVisual.moveStyleProps.skateboard.GetComponent<MeshFilter>().sharedMesh = null;
				}
				break;
			case 0:
				if ((Object)(object)playerComponent != (Object)null && playerComponent.HasCustomBmx)
				{
					player.characterVisual.moveStyleProps.bmxFrame.GetComponent<MeshFilter>().sharedMesh = null;
					player.characterVisual.moveStyleProps.bmxGear.GetComponent<MeshFilter>().sharedMesh = null;
					player.characterVisual.moveStyleProps.bmxHandlebars.GetComponent<MeshFilter>().sharedMesh = null;
					player.characterVisual.moveStyleProps.bmxPedalL.GetComponent<MeshFilter>().sharedMesh = null;
					player.characterVisual.moveStyleProps.bmxPedalR.GetComponent<MeshFilter>().sharedMesh = null;
					player.characterVisual.moveStyleProps.bmxWheelF.GetComponent<MeshFilter>().sharedMesh = null;
					player.characterVisual.moveStyleProps.bmxWheelR.GetComponent<MeshFilter>().sharedMesh = null;
				}
				break;
			}
		}
	}
	public class MPMapController : MonoBehaviour
	{
		private MPMapUI _mapUI;

		private WorldHandler _worldHandler;

		private UIManager _uiManager;

		private Mapcontroller _mapController;

		private BaseModule _baseModule;

		private MPSettings _mpSettings;

		private ClientController _clientController;

		private bool _mapActive;

		public static MPMapController Instance { get; private set; }

		public bool BeingDisplayed { get; private set; }

		private void Awake()
		{
			Instance = this;
			_worldHandler = WorldHandler.instance;
			_uiManager = Core.Instance.UIManager;
			_mapController = Mapcontroller.Instance;
			_baseModule = Core.Instance.BaseModule;
			_mpSettings = MPSettings.Instance;
			_clientController = ClientController.Instance;
			GameObject gameObject = ((Component)((Component)this).transform.Find("Canvas").Find("Map")).gameObject;
			_mapUI = gameObject.AddComponent<MPMapUI>();
			_mapActive = ((Component)_mapUI).gameObject.activeSelf;
		}

		private void Update()
		{
			bool flag = false;
			if ((Object)(object)_mapController == (Object)null)
			{
				return;
			}
			if (ShouldDisplayMap())
			{
				flag = true;
				if (!((Behaviour)_mapController.m_Camera).enabled)
				{
					((Behaviour)_mapController.m_Camera).enabled = true;
				}
				if (!BeingDisplayed)
				{
					_mapController.RestoreDefaultMapControllerState();
				}
				BeingDisplayed = true;
			}
			else
			{
				flag = false;
				BeingDisplayed = false;
			}
			if (flag != _mapActive)
			{
				_mapActive = flag;
				((Component)_mapUI).gameObject.SetActive(_mapActive);
			}
		}

		private MinimapOverrideModes GetCurrentMinimapOverrideMode()
		{
			if ((Object)(object)_clientController == (Object)null)
			{
				return MinimapOverrideModes.None;
			}
			Lobby currentLobby = _clientController.ClientLobbyManager.CurrentLobby;
			if (currentLobby == null)
			{
				return MinimapOverrideModes.None;
			}
			if (!currentLobby.InGame)
			{
				return MinimapOverrideModes.None;
			}
			return currentLobby.CurrentGamemode.MinimapOverrideMode;
		}

		private bool ShouldDisplayMap()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Invalid comparison between Unknown and I4
			if (_baseModule.IsInGamePaused)
			{
				return false;
			}
			if (!((Component)_uiManager.gameplay.gameplayScreen).gameObject.activeInHierarchy)
			{
				return false;
			}
			Player currentPlayer = _worldHandler.GetCurrentPlayer();
			if ((int)currentPlayer.phone.state != 0 && (int)currentPlayer.phone.state != 3)
			{
				return false;
			}
			switch (GetCurrentMinimapOverrideMode())
			{
			case MinimapOverrideModes.ForceOn:
				return true;
			case MinimapOverrideModes.ForceOff:
				return false;
			default:
				if (!_mpSettings.ShowMinimap)
				{
					return false;
				}
				return true;
			}
		}

		public static void Create()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			GameObject obj = Object.Instantiate<GameObject>(MPAssets.Instance.Bundle.LoadAsset<GameObject>("Map UI"));
			obj.transform.SetParent(((Component)Core.Instance.UIManager).transform, false);
			obj.AddComponent<MPMapController>();
		}
	}
	public class MPMapUI : MonoBehaviour
	{
		private TextMeshProUGUI _personCountLabel;

		private TextMeshProUGUI _notificationCountLabel;

		private ClientController _clientController;

		private void Awake()
		{
			Mapcontroller instance = Mapcontroller.Instance;
			_clientController = ClientController.Instance;
			RawImage component = ((Component)((Component)this).transform.Find("Map Texture")).GetComponent<RawImage>();
			_personCountLabel = ((Component)((Component)this).transform.Find("People Count")).GetComponent<TextMeshProUGUI>();
			_notificationCountLabel = ((Component)((Component)this).transform.Find("Notification Count")).GetComponent<TextMeshProUGUI>();
			component.texture = (Texture)(object)instance.m_Camera.targetTexture;
		}

		private void Update()
		{
			if (!_clientController.Connected)
			{
				((TMP_Text)_personCountLabel).text = "Offline";
			}
			else
			{
				((TMP_Text)_personCountLabel).text = _clientController.Players.Count.ToString();
			}
			((TMP_Text)_notificationCountLabel).text = _clientController.ClientLobbyManager.LobbiesInvited.Count.ToString();
		}
	}
	public abstract class MPMoveStyleSkin : MPUnlockable
	{
		public string Title = "";

		public string HowToUnlock = string.Empty;

		public Texture Texture;

		public Material[] Materials;

		public abstract MoveStyle MoveStyle { get; }

		public MPMoveStyleSkin(string title, string howToUnlock, int id, bool unlockedByDefault, Texture texture, Material[] materials)
			: base(id, unlockedByDefault)
		{
			Title = title;
			Texture = texture;
			HowToUnlock = howToUnlock;
			Materials = materials;
		}

		public virtual void ApplyToPlayer(Player player)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected I4, but got Unknown
			PlayerComponent playerComponent = PlayerComponent.Get(player);
			playerComponent.ApplyMoveStyleSkin(0);
			playerComponent.MovestyleSkin = this;
			if (Materials != null)
			{
				playerComponent.ApplyMoveStyleMaterial(Materials);
			}
			else
			{
				if (!((Object)(object)Texture != (Object)null))
				{
					return;
				}
				MoveStyle moveStyle = MoveStyle;
				switch (moveStyle - 1)
				{
				case 2:
				{
					Material[] moveStyleMaterials = MoveStyleLoader.GetMoveStyleMaterials(player, (MoveStyle)3);
					for (int i = 0; i < moveStyleMaterials.Length; i++)
					{
						moveStyleMaterials[i].mainTexture = Texture;
					}
					break;
				}
				case 0:
				{
					Material[] moveStyleMaterials = MoveStyleLoader.GetMoveStyleMaterials(player, (MoveStyle)1);
					for (int i = 0; i < moveStyleMaterials.Length; i++)
					{
						moveStyleMaterials[i].mainTexture = Texture;
					}
					break;
				}
				case 1:
				{
					Material[] moveStyleMaterials = MoveStyleLoader.GetMoveStyleMaterials(player, (MoveStyle)2);
					for (int i = 0; i < moveStyleMaterials.Length; i++)
					{
						moveStyleMaterials[i].mainTexture = Texture;
					}
					break;
				}
				}
			}
		}
	}
	public class MPPlayer
	{
		[CompilerGenerated]
		private sealed class <ApplyCurrentAnimationToPlayerDelayed>d__32 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public MPPlayer <>4__this;

			public Player player;

			private int <animation>5__2;

			private float <time>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ApplyCurrentAnimationToPlayerDelayed>d__32(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Expected I4, but got Unknown
				try
				{
					int num = <>1__state;
					MPPlayer mPPlayer = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = null;
						<>1__state = 1;
						return true;
					case 1:
					{
						<>1__state = -1;
						<animation>5__2 = mPPlayer.ClientVisualState.CurrentAnimation;
						<time>5__3 = mPPlayer.ClientVisualState.CurrentAnimationTime;
						if (mPPlayer.ClientVisualState.BoEAnimation)
						{
							int num2 = default(int);
							if (BunchOfEmotesSupport.TryGetGameAnimationForCustomAnimationHash(<animation>5__2, ref num2))
							{
								<animation>5__2 = num2;
							}
							else
							{
								<animation>5__2 = ClientConstants.MissingAnimationHash;
							}
						}
						MoveStyle moveStyle = player.moveStyle;
						switch (moveStyle - 1)
						{
						case 0:
							player.anim.runtimeAnimatorController = player.animatorControllerBMX;
							break;
						case 1:
						case 3:
							player.anim.runtimeAnimatorController = player.animatorControllerSkateboard;
							break;
						case 2:
							player.anim.runtimeAnimatorController = player.animatorControllerSkates;
							break;
						}
						PlayerPatch.PlayAnimPatchEnabled = false;
						<>1__state = -3;
						player.PlayAnim(<animation>5__2, true, true, <time>5__3);
						PlayerPatch.PlayAnimPatchEnabled = true;
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					case 2:
					{
						<>1__state = -3;
						PlayerPatch.PlayAnimPatchEnabled = false;
						AnimatorClipInfo[] currentAnimatorClipInfo = player.anim.GetCurrentAnimatorClipInfo(0);
						if (currentAnimatorClipInfo.Length != 0)
						{
							<time>5__3 /= ((AnimatorClipInfo)(ref currentAnimatorClipInfo[0])).clip.length;
							player.PlayAnim(<animation>5__2, true, true, <time>5__3);
						}
						<>m__Finally1();
						return false;
					}
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				PlayerPatch.PlayAnimPatchEnabled = true;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <UpdateMoveStyleDelayed>d__49 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public MPPlayer <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <UpdateMoveStyleDelayed>d__49(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				MPPlayer mPPlayer = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					mPPlayer.UpdateMoveStyle();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public ushort ClientId;

		public ClientState ClientState;

		public ClientVisualState ClientVisualState;

		public Player Player;

		private PlayerComponent _cachedPlayerComp;

		public bool Teleporting = true;

		public int Outfit;

		private PlayerStates _previousState;

		public Nameplate NamePlate;

		private Lobby _lobby;

		private MapPin _mapPin;

		private GameObject _mapPinParticles;

		private Material _mapPinMaterial;

		private int _lastMoveStyleSkin = -1;

		private int _lastMPMoveStyleSkin = -1;

		private int _lastAnimation;

		private float _timeSpentInWrongAnimation;

		private const float MaxTimeSpentInWrongAnimation = 0.5f;

		private PlayerInteractable _interactable;

		public bool CustomVisibility;

		public bool CustomTransform;

		public static List<Action> OptimizationActions = new List<Action>();

		private bool _targetLod;

		private bool _targetHidden;

		public bool Local => ClientId == ClientController.Instance.LocalID;

		public PlayerComponent PlayerComponent
		{
			get
			{
				if ((Object)(object)_cachedPlayerComp == (Object)null)
				{
					_cachedPlayerComp = PlayerComponent.Get(Player);
				}
				return _cachedPlayerComp;
			}
		}

		public void UpdateVisualState(ClientVisualState newVisualState)
		{
			ClientVisualState = newVisualState;
			if (ClientVisualState.MoveStyle >= 5 || ClientVisualState.MoveStyle < 0)
			{
				ClientVisualState.MoveStyle = Mathf.Clamp(ClientVisualState.MoveStyle, 0, 4);
			}
		}

		public bool ShouldIgnore()
		{
			//IL_003a: 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)
			if (ClientVisualState != null && ClientVisualState.Ignore)
			{
				return true;
			}
			ClientController instance = ClientController.Instance;
			Lobby currentLobby = instance.ClientLobbyManager.CurrentLobby;
			if (currentLobby != null && currentLobby.InGame && GamemodeFactory.IsExclusive(currentLobby.LobbyState.Gamemode) && _lobby != currentLobby)
			{
				return true;
			}
			if (_lobby != null && _lobby.LobbyState.InGame && GamemodeFactory.IsExclusive(_lobby.LobbyState.Gamemode) && _lobby != currentLobby)
			{
				return true;
			}
			if (_lobby != null && _lobby.LobbyState.InGame && _lobby == currentLobby)
			{
				PropDisguiseController instance2 = PropDisguiseController.Instance;
				if (_lobby.LobbyState.Players[ClientId].Team != _lobby.LobbyState.Players[instance.LocalID].Team && instance2.InPropHunt && instance2.InSetupPhase)
				{
					return true;
				}
			}
			return false;
		}

		private void MakeMapPin()
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			Mapcontroller instance = Mapcontroller.Instance;
			_mapPin = instance.CreatePin((PinType)2);
			_mapPin.AssignGameplayEvent(((Component)Player).gameObject);
			_mapPin.InitMapPin((PinType)2);
			_mapPin.OnPinEnable();
			GameObject gameObject = ((Component)((Component)_mapPin).transform.Find("InViewVisualization")).gameObject;
			_mapPinParticles = ((Component)gameObject.transform.Find("Particle System")).gameObject;
			_mapPinParticles.SetActive(false);
			GameObject gameObject2 = ((Component)((Component)_mapPin).transform.Find("OutOfViewVisualization")).gameObject;
			ParticleSystem component = gameObject2.GetComponent<ParticleSystem>();
			ParticleSystemRenderer component2 = gameObject2.GetComponent<ParticleSystemRenderer>();
			Object.Destroy((Object)(object)component);
			Object.Destroy((Object)(object)component2);
			MeshRenderer component3 = gameObject.GetComponent<MeshRenderer>();
			if ((Object)(object)_mapPinMaterial == (Object)null)
			{
				_mapPinMaterial = new Material(((Renderer)component3).sharedMaterial);
				_mapPinMaterial.color = new Color(1f, 1f, 1f);
			}
			((Renderer)component3).sharedMaterial = _mapPinMaterial;
		}

		private bool IsSpecialPlayer()
		{
			if (ClientState.User != null)
			{
				return ClientState.User.HasTag("elite");
			}
			return false;
		}

		private bool InSameLobbyAsLocalPlayer()
		{
			Lobby currentLobby = ClientController.Instance.ClientLobbyManager.CurrentLobby;
			if (currentLobby == null)
			{
				return false;
			}
			if (_lobby == null)
			{
				return false;
			}
			return currentLobby == _lobby;
		}

		private bool InOurTeamLobby(out bool rival)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			rival = false;
			ClientController instance = ClientController.Instance;
			Lobby currentLobby = instance.ClientLobbyManager.CurrentLobby;
			if (currentLobby == null)
			{
				return false;
			}
			if (_lobby == null)
			{
				return false;
			}
			if (currentLobby == _lobby)
			{
				LobbyPlayer val = currentLobby.LobbyState.Players[instance.LocalID];
				LobbyPlayer val2 = currentLobby.LobbyState.Players[ClientId];
				Gamemode gamemode = GamemodeFactory.GetGamemode(currentLobby.LobbyState.Gamemode);
				rival = val2.Team != val.Team;
				return gamemode.TeamBased;
			}
			return false;
		}

		private bool IsChallengeable()
		{
			if (ClientController.Instance.ClientLobbyManager.CurrentLobby != null)
			{
				return false;
			}
			if (_lobby == null)
			{
				return false;
			}
			if (_lobby.LobbyState.Challenge && !_lobby.LobbyState.InGame)
			{
				return _lobby.LobbyState.HostId == ClientId;
			}
			return false;
		}

		[IteratorStateMachine(typeof(<ApplyCurrentAnimationToPlayerDelayed>d__32))]
		private IEnumerator ApplyCurrentAnimationToPlayerDelayed(Player player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyCurrentAnimationToPlayerDelayed>d__32(0)
			{
				<>4__this = this,
				player = player
			};
		}

		private bool CalculateChunkVisibility(List<StageChunk> chunks)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (chunks == null || chunks.Count <= 0)
			{
				return true;
			}
			bool flag = false;
			foreach (StageChunk chunk in chunks)
			{
				BoxCollider[] colliders = chunk.colliders;
				foreach (BoxCollider val in colliders)
				{
					if (StageChunk.PointInOBB(((Component)Player).transform.position, val))
					{
						flag = true;
						if (chunk.isActive)
						{
							return true;
						}
					}
				}
			}
			return !flag;
		}

		public bool CalculateVisibility(List<Plane[]> frustumPlanes, List<StageChunk> stageChunks)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player == (Object)null)
			{
				return false;
			}
			if (CalculateChunkVisibility(stageChunks))
			{
				foreach (Plane[] frustumPlane in frustumPlanes)
				{
					if (GeometryUtility.TestPlanesAABB(frustumPlane, ((Renderer)Player.characterVisual.mainRenderer).bounds))
					{
						return true;
					}
				}
			}
			return false;
		}

		private void Hide()
		{
			Player.characterVisual.SetSpraycan(false, (Characters)(-1));
			if ((Object)(object)Player != (Object)null && (Object)(object)Player.characterVisual != (Object)null)
			{
				((Component)Player.characterVisual).gameObject.SetActive(false);
			}
			if ((Object)(object)NamePlate != (Object)null)
			{
				((Component)NamePlate).gameObject.SetActive(false);
			}
		}

		private void Unhide()
		{
			if (!((Object)(object)Player != (Object)null) || !((Object)(object)Player.characterVisual != (Object)null))
			{
				return;
			}
			if (!((Component)Player.characterVisual).gameObject.activeSelf)
			{
				Player.characterVisual.SetSpraycan(false, (Characters)(-1));
				((MonoBehaviour)Player).StartCoroutine(ApplyCurrentAnimationToPlayerDelayed(Player));
			}
			((Component)Player.characterVisual).gameObject.SetActive(true);
			if (_targetLod != PlayerComponent.LOD)
			{
				RefreshCharacterVisuals();
				PlayerComponent.LOD = _targetLod;
				if (_targetLod)
				{
					PlayerComponent.MakeLOD();
				}
			}
		}

		private void ClearOptimizationActions()
		{
			OptimizationActions.Remove(Hide);
			OptimizationActions.Remove(Unhide);
		}

		public void FrameUpdate(bool hidden, bool lod)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Invalid comparison between Unknown and I4
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Invalid comparison between Unknown and I4
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Invalid comparison between Unknown and I4
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Invalid comparison between Unknown and I4
			//IL_0165: 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_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: 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_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0606: Unknown result type (might be due to invalid IL or missing references)
			//IL_060c: Invalid comparison between Unknown and I4
			//IL_0590: Unknown result type (might be due to invalid IL or missing references)
			//IL_061a: Unknown result type (might be due to invalid IL or missing references)
			//IL_061f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0629: Unknown result type (might be due to invalid IL or missing references)
			//IL_062e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player == (Object)null)
			{
				return;
			}
			if (ShouldIgnore() && ((Component)Player).gameObject.activeSelf)
			{
				((Component)Player).gameObject.SetActive(false);
			}
			else if (!ShouldIgnore() && !((Component)Player).gameObject.activeSelf)
			{
				DeletePlayer();
				UpdateClientStateVisuals();
				RefreshCharacterVisuals();
			}
			_ = MPSettings.Instance;
			if ((Object)(object)_interactable != (Object)null)
			{
				Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
				if (CustomSequenceHandler.instance.sequence == _interactable.Sequence && ((int)currentPlayer.sequenceState == 1 || (int)currentPlayer.sequenceState == 2))
				{
					hidden = true;
				}
			}
			if (ClientState == null || ClientVisualState == null)
			{
				return;
			}
			if (!CustomVisibility)
			{
				if (ClientVisualState.Disguised || ShouldIgnore())
				{
					if (((Component)Player.visualTf).gameObject.activeSelf)
					{
						((Component)Player.visualTf).gameObject.SetActive(false);
					}
					hidden = true;
					lod = false;
				}
				if (hidden || lod)
				{
					Player.RemoveGraffitiSlash();
				}
			}
			else
			{
				lod = false;
				hidden = true;
			}
			_targetLod = lod;
			_targetHidden = hidden;
			if ((int)ClientVisualState.State == 2)
			{
				Teleporting = true;
			}
			if (!CustomTransform)
			{
				Vector3 val = ClientVisualState.Position.ToUnityVector3();
				Vector3 val2 = ClientVisualState.VisualPosition.ToUnityVector3();
				Quaternion val3 = ClientVisualState.Rotation.ToUnityQuaternion();
				Quaternion val4 = ClientVisualState.VisualRotation.ToUnityQuaternion();
				Vector3 velocity = ClientVisualState.Velocity.ToUnityVector3();
				if (Teleporting)
				{
					Teleporting = false;
					Player.SetPosAndRotHard(val, val3);
					Player.visualTf.localPosition = val2;
					Player.visualTf.localRotation = val4;
					Player.anim.SetFloat(ClientConstants.GrindDirectionHash, ClientVisualState.GrindDirection);
					Player.anim.SetFloat(ClientConstants.PhoneDirectionXHash, ClientVisualState.PhoneDirectionX);
					Player.anim.SetFloat(ClientConstants.PhoneDirectionYHash, ClientVisualState.PhoneDirectionY);
					Player.anim.SetFloat(ClientConstants.TurnDirection1Hash, ClientVisualState.TurnDirection1);
					Player.anim.SetFloat(ClientConstants.TurnDirection2Hash, ClientVisualState.TurnDirection2);
					Player.anim.SetFloat(ClientConstants.TurnDirection3Hash, ClientVisualState.TurnDirection3);
					Player.anim.SetFloat(ClientConstants.TurnDirectionSkateboardHash, ClientVisualState.TurnDirectionSkateboard);
				}
				else
				{
					((Component)Player).transform.position = Vector3.Lerp(((Component)Player).transform.position, val, Time.deltaTime * 12f);
					((Component)Player).transform.rotation = Quaternion.Lerp(((Component)Player).transform.rotation, val3, Time.deltaTime * 12f);
					Player.visualTf.localRotation = Quaternion.Lerp(Player.visualTf.localRotation, val4, Time.deltaTime * 12f);
					Player.visualTf.localPosition = Vector3.Lerp(Player.visualTf.localPosition, val2, Time.deltaTime * 12f);
					Player.anim.SetFloat(ClientConstants.GrindDirectionHash, Mathf.Lerp(Player.anim.GetFloat(ClientConstants.GrindDirectionHash), ClientVisualState.GrindDirection, Time.deltaTime * 12f));
					Player.anim.SetFloat(ClientConstants.PhoneDirectionXHash, Mathf.Lerp(Player.anim.GetFloat(ClientConstants.PhoneDirectionXHash), ClientVisualState.PhoneDirectionX, Time.deltaTime * 12f));
					Player.anim.SetFloat(ClientConstants.PhoneDirectionYHash, Mathf.Lerp(Player.anim.GetFloat(ClientConstants.PhoneDirectionYHash), ClientVisualState.PhoneDirectionY, Time.deltaTime * 12f));
					Player.anim.SetFloat(ClientConstants.TurnDirection1Hash, Mathf.Lerp(Player.anim.GetFloat(ClientConstants.TurnDirection1Hash), ClientVisualState.TurnDirection1, Time.deltaTime * 12f));
					Player.anim.SetFloat(ClientConstants.TurnDirection2Hash, Mathf.Lerp(Player.anim.GetFloat(ClientConstants.TurnDirection2Hash), ClientVisualState.TurnDirection2, Time.deltaTime * 12f));
					Player.anim.SetFloat(ClientConstants.TurnDirection3Hash, Mathf.Lerp(Player.anim.GetFloat(ClientConstants.TurnDirection3Hash), ClientVisualState.TurnDirection3, Time.deltaTime * 12f));
					Player.anim.SetFloat(ClientConstants.TurnDirectionSkateboardHash, Mathf.Lerp(Player.anim.GetFloat(ClientConstants.TurnDirectionSkateboardHash), ClientVisualState.TurnDirectionSkateboard, Time.deltaTime * 12f));
				}
				Player.motor._rigidbody.velocity = velocity;
			}
			if ((int)ClientVisualState.State == 2)
			{
				Teleporting = true;
			}
			UpdateLookAt();
			UpdatePhone();
			UpdateSprayCan();
			if ((Object)(object)NamePlate != (Object)null)
			{
				((Component)NamePlate).transform.position = ((Component)Player).transform.position + Vector3.up * 2f;
				if ((int)ClientVisualState.State == 2)
				{
					Transform transform = ((Component)NamePlate).transform;
					transform.position += Vector3.up * 2f;
				}
			}
		}

		public void UpdateLobby()
		{
			ClientController instance = ClientController.Instance;
			_lobby = null;
			foreach (KeyValuePair<uint, Lobby> lobby in instance.ClientLobbyManager.Lobbies)
			{
				if (lobby.Value.LobbyState.Players.ContainsKey(ClientId))
				{
					_lobby = lobby.Value;
					break;
				}
			}
		}

		private void RefreshCharacterVisuals()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Invalid comparison between Unknown and I4
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Invalid comparison between Unknown and I4
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Invalid comparison between Unknown and I4
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Invalid comparison between Unknown and I4
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Invalid comparison between Unknown and I4
			//IL_00e6: 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_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			if (ClientId == ClientController.Instance.LocalID && !MPSettings.Instance.DebugLocalPlayer)
			{
				return;
			}
			Player.characterVisual.SetSpraycan(false, (Characters)(-1));
			Player.RemoveGraffitiSlash();
			PlayerComponent.Chibi = ClientVisualState.Chibi;
			Player.character = (Characters)(-1);
			Characters val = (Characters)ClientState.Character;
			Characters val2 = (Characters)ClientState.FallbackCharacter;
			if ((int)val >= 26 || (int)val <= -1)
			{
				val = (Characters)3;
			}
			if ((int)val2 >= 26 || (int)val2 <= -1)
			{
				val2 = (Characters)3;
			}
			byte b = ClientState.Outfit;
			bool flag = false;
			if (ClientState.CrewBoomCharacter != Guid.Empty)
			{
				val = val2;
				if (CrewBoomSupport.Installed)
				{
					val = CrewBoomSupport.GetCharacterForGuid(ClientState.CrewBoomCharacter, (Characters)(-1));
					if ((int)val == -1)
					{
						if (CrewBoomStreamer.HasCharacter(ClientState.CrewBoomCharacter))
						{
							flag = true;
						}
						else
						{
							val = val2;
							b = ClientState.FallbackOutfit;
						}
					}
				}
				else
				{
					b = ClientState.FallbackOutfit;
				}
			}
			if (b < 0 || b > 3)
			{
				b = 0;
			}
			if (flag)
			{
				PlayerComponent.SetStreamedCharacter(ClientState.CrewBoomCharacter, b);
				Outfit = b;
			}
			else
			{
				if ((int)ClientState.SpecialSkin == -1)
				{
					Player.SetCharacter(val, (int)b);
					Player.InitVisual();
					Outfit = b;
				}
				SpecialSkinManager.Instance.ApplySpecialSkinToPlayer(Player, ClientState.SpecialSkin);
				SpecialSkinManager.Instance.ApplySpecialSkinVariantToPlayer(Player, ClientState.SpecialSkinVariant);
			}
			UpdateNameplate();
			Teleporting = true;
			if (!Object.op_Implicit((Object)(object)((Component)Player.anim).GetComponent<InverseKinematicsRelay>()))
			{
				((Component)Player.anim).gameObject.AddComponent<InverseKinematicsRelay>();
			}
			if (ClientVisualState.CurrentAnimation != 0)
			{
				_timeSpentInWrongAnimation = 0f;
				((MonoBehaviour)Player).StartCoroutine(ApplyCurrentAnimationToPlayerDelayed(Player));
			}
			UpdateMoveStyleSkin();
			PlayerComponent.UpdateChibi();
		}

		public void UpdateClientStateVisuals()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Invalid comparison between Unknown and I4
			//IL_0052: 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_004f: Invalid comparison between Unknown and I4
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Invalid comparison between Unknown and I4
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Invalid comparison between Unknown and I4
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Invalid comparison between Unknown and I4
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			if (ClientState == null || ClientVisualState == null || (ClientId == ClientController.Instance.LocalID && !MPSettings.Instance.DebugLocalPlayer))
			{
				return;
			}
			Characters val = (Characters)ClientState.Character;
			Characters val2 = (Characters)ClientState.FallbackCharacter;
			if ((int)val >= 26 || (int)val <= -1)
			{
				val = (Characters)3;
			}
			if ((int)val2 >= 26 || (int)val2 <= -1)
			{
				val2 = (Characters)3;
			}
			byte b = ClientState.Outfit;
			bool flag = false;
			if (ClientState.CrewBoomCharacter != Guid.Empty)
			{
				val = val2;
				if (CrewBoomSupport.Installed)
				{
					val = CrewBoomSupport.GetCharacterForGuid(ClientState.CrewBoomCharacter, (Characters)(-1));
					if ((int)val == -1)
					{
						if (CrewBoomStreamer.HasCharacter(ClientState.CrewBoomCharacter))
						{
							flag = true;
						}
						else
						{
							val = val2;
							b = ClientState.FallbackOutfit;
						}
					}
				}
				else
				{
					b = ClientState.FallbackOutfit;
				}
			}
			if (PlayerComponent?.StreamedCharacter != null && !flag && (Object)(object)Player != (Object)null)
			{
				Player.character = (Characters)(-1);
			}
			if (b < 0 || b > 3)
			{
				b = 0;
			}
			bool flag2 = false;
			if ((Object)(object)Player == (Object)null)
			{
				if (flag)
				{
					Player = MPUtility.CreateMultiplayerPlayer(val2, ClientState.FallbackOutfit, this);
				}
				else
				{
					Player = MPUtility.CreateMultiplayerPlayer(val, b, this);
				}
				Outfit = b;
				flag2 = true;
			}
			PlayerComponent.Chibi = ClientVisualState.Chibi;
			if (Player.character != val && !flag && (int)ClientState.SpecialSkin == -1)
			{
				Player.RemoveGraffitiSlash();
				Player.SetCharacter(val, (int)b);
				Player.InitVisual();
				Outfit = b;
				flag2 = true;
			}
			if (Outfit != b && !flag && (int)ClientState.SpecialSkin == -1)
			{
				Player.SetOutfit((int)b);
				Outfit = b;
			}
			if (flag)
			{
				if (PlayerComponent.StreamedCharacter == null || PlayerComponent.StreamedCharacter.Handle.GUID != ClientState.CrewBoomCharacter)
				{
					PlayerComponent.SetStreamedCharacter(ClientState.CrewBoomCharacter, b);
				}
				if (PlayerComponent.StreamedCharacter != null && PlayerComponent.StreamedCharacter.Outfit != b)
				{
					PlayerComponent.StreamedCharacter.ApplyOutfit(b);
				}
				PlayerComponent.StreamedOutfit = b;
				Outfit = b;
			}
			if (ClientState.SpecialSkin != PlayerComponent.SpecialSkin)
			{
				SpecialSkinManager.Instance.ApplySpecialSkinToPlayer(Player, ClientState.SpecialSkin);
				flag2 = true;
			}
			if (ClientState.SpecialSkinVariant != PlayerComponent.SpecialSkinVariant)
			{
				SpecialSkinManager.Instance.ApplySpecialSkinVariantToPlayer(Player, ClientState.SpecialSkinVariant);
			}
			if (flag2)
			{
				UpdateNameplate();
				Teleporting = true;
				if (!Object.op_Implicit((Object)(object)((Component)Player.anim).GetComponent<InverseKinematicsRelay>()))
				{
					((Component)Player.anim).gameObject.AddComponent<InverseKinematicsRelay>();
				}
				if (ClientVisualState.CurrentAnimation != 0)
				{
					_timeSpentInWrongAnimation = 0f;
					((MonoBehaviour)Player).StartCoroutine(ApplyCurrentAnimationToPlayerDelayed(Player));
				}
				UpdateMoveStyleSkin();
			}
		}

		public void OnSkinLoaded()
		{
			if (ClientVisualState.CurrentAnimation != 0)
			{
				_timeSpentInWrongAnimation = 0f;
				((MonoBehaviour)Player).StartCoroutine(ApplyCurrentAnimationToPlayerDelayed(Player));
			}
		}

		public void TickUpdate()
		{
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Invalid comparison between Unknown and I4
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Invalid comparison between Unknown and I4
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0503: Invalid comparison between Unknown and I4
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Invalid comparison between Unknown and I4
			//IL_0579: Unknown result type (might be due to invalid IL or missing references)
			//IL_057f: Invalid comparison between Unknown and I4
			//IL_0827: Unknown result type (might be due to invalid IL or missing references)
			//IL_082c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0816: Unknown result type (might be due to invalid IL or missing references)
			ClientController instance = ClientController.Instance;
			MPSettings instance2 = MPSettings.Instance;
			if (!instance2.DebugLocalPlayer && ClientId == instance.LocalID)
			{
				if ((Object)(object)NamePlate != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)NamePlate).gameObject);
					NamePlate = null;
				}
				if ((Object)(object)Player != (Object)null)
				{
					DeletePlayer();
				}
				return;
			}
			_ = WorldHandler.instance;
			if (ClientState == null || ClientVisualState == null)
			{
				if ((Object)(object)Player != (Object)null)
				{
					DeletePlayer();
				}
				return;
			}
			if (!ClientVisualState.Disguised && !ShouldIgnore() && !CustomVisibility)
			{
				if (_targetHidden)
				{
					if (instance2.OptimizeOnePlayerAtATime)
					{
						if (((Component)Player.characterVisual).gameObject.activeSelf)
						{
							ClearOptimizationActions();
							OptimizationActions.Add(Hide);
						}
					}
					else
					{
						Hide();
					}
					Player.characterVisual.SetSpraycan(false, (Characters)(-1));
				}
				else if (instance2.OptimizeOnePlayerAtATime)
				{
					if (!((Component)Player.characterVisual).gameObject.activeSelf || _targetLod != PlayerComponent.LOD)
					{
						ClearOptimizationActions();
						OptimizationActions.Add(Unhide);
					}
				}
				else
				{
					Unhide();
				}
			}
			if ((Object)(object)NamePlate != (Object)null && instance2.ShowNamePlates)
			{
				if (ClientVisualState.Disguised || ShouldIgnore())
				{
					((Component)NamePlate).gameObject.SetActive(false);
				}
				else
				{
					((Component)NamePlate).gameObject.SetActive(true);
				}
			}
			else if ((Object)(object)NamePlate != (Object)null && !instance2.ShowNamePlates)
			{
				((Component)NamePlate).gameObject.SetActive(false);
			}
			bool flag = false;
			if (!ShouldIgnore())
			{
				if (ClientVisualState.Chibi != PlayerComponent.Chibi)
				{
					UpdateClientStateVisuals();
					RefreshCharacterVisuals();
				}
				PlayerComponent.AFK = ClientVisualState.AFK;
				PlayerComponent.Chibi = ClientVisualState.Chibi;
				if ((int)ClientVisualState.State == 2)
				{
					Player.characterVisual.feetIK = false;
				}
				int num = ClientVisualState.CurrentAnimation;
				if (ClientVisualState.BoEAnimation)
				{
					int num2 = default(int);
					num = ((!BunchOfEmotesSupport.TryGetGameAnimationForCustomAnimationHash(num, ref num2)) ? ClientConstants.MissingAnimationHash : num2);
				}
				if (Player.curAnim != num)
				{
					if (Player.curAnim != _lastAnimation)
					{
						_timeSpentInWrongAnimation = 0f;
					}
					_timeSpentInWrongAnimation += ClientController.DeltaTime;
				}
				else
				{
					_timeSpentInWrongAnimation = 0f;
				}
				_lastAnimation = Player.curAnim;
				if (_timeSpentInWrongAnimation >= 0.5f)
				{
					flag = true;
				}
				if (flag && ClientVisualState.CurrentAnimation != 0)
				{
					_timeSpentInWrongAnimation = 0f;
					((MonoBehaviour)Player).StartCoroutine(ApplyCurrentAnimationToPlayerDelayed(Player));
				}
				if ((int)Player.moveStyleEquipped != ClientVisualState.MoveStyle || Player.usingEquippedMovestyle != ClientVisualState.MoveStyleEquipped)
				{
					((MonoBehaviour)Player).StartCoroutine(UpdateMoveStyleDelayed());
				}
			}
			bool rival;
			bool flag2 = InOurTeamLobby(out rival);
			TickUpdateNameplate();
			if ((Object)(object)_mapPin == (Object)null)
			{
				MakeMapPin();
			}
			_mapPin.SetLocation();
			if (ClientVisualState.Disguised || ShouldIgnore())
			{
				((Component)_mapPin).gameObject.SetActive(false);
			}
			else
			{
				((Component)_mapPin).gameObject.SetActive(true);
			}
			if (rival && flag2)
			{
				_mapPinMaterial.color = new Color(0.9f, 0.9f, 0f);
			}
			else if (InSameLobbyAsLocalPlayer())
			{
				_mapPinMaterial.color = new Color(0f, 0.9f, 0f);
			}
			else
			{
				_mapPinMaterial.color = new Color(0.9f, 0.9f, 0.9f);
			}
			if ((Object)(object)_interactable == (Object)null)
			{
				_interactable = PlayerInteractable.Create(this);
			}
			if (_lobby == null)
			{
				_interactable.AlreadyTalked = false;
			}
			if (IsChallengeable())
			{
				_mapPinMaterial.color = new Color(0f, 0.8f, 0.9f);
				_mapPinParticles.SetActive(true);
				((Component)_interactable).gameObject.SetActive(true);
				PlayerComponent.ChallengeIndicatorVisible = true;
			}
			else
			{
				_mapPinParticles.SetActive(false);
				((Component)_interactable).gameObject.SetActive(false);
				PlayerComponent.ChallengeIndicatorVisible = false;
			}
			if ((int)Player.characterVisual.boostpackEffectMode != ClientVisualState.BoostpackEffectMode)
			{
				Player.characterVisual.SetBoostpackEffect((BoostpackEffectMode)ClientVisualState.BoostpackEffectMode, -1f);
			}
			if ((int)Player.characterVisual.frictionEffectMode != ClientVisualState.FrictionEffectMode)
			{
				Player.characterVisual.SetFrictionEffect((FrictionEffectMode)ClientVisualState.FrictionEffectMode);
			}
			Player.SetDustEmission((int)ClientVisualState.DustEmissionRate);
			if ((int)ClientVisualState.State != 1)
			{
				Player.RemoveGraffitiSlash();
			}
			if (ClientVisualState.MoveStyleSkin != _lastMoveStyleSkin || ClientVisualState.MPMoveStyleSkin != _lastMPMoveStyleSkin)
			{
				UpdateMoveStyleSkin();
			}
			if (ClientVisualState.Hitbox)
			{
				Player.hitbox.SetActive(true);
			}
			else
			{
				Player.hitbox.SetActive(false);
			}
			if (ClientVisualState.HitboxLeftLeg)
			{
				Player.hitboxLeftLeg.SetActive(true);
			}
			else
			{
				Player.hitboxLeftLeg.SetActive(false);
			}
			if (ClientVisualState.HitboxRightLeg)
			{
				Player.hitboxRightLeg.SetActive(true);
			}
			else
			{
				Player.hitboxRightLeg.SetActive(false);
			}
			if (ClientVisualState.HitboxUpperBody)
			{
				Player.hitboxUpperBody.SetActive(true);
			}
			else
			{
				Player.hitboxUpperBody.SetActive(false);
			}
			if (ClientVisualState.HitboxAerial)
			{
				Player.airialHitbox.SetActive(true);
			}
			else
			{
				Player.airialHitbox.SetActive(false);
			}
			if (ClientVisualState.HitboxRadial)
			{
				Player.radialHitbox.SetActive(true);
			}
			else
			{
				Player.radialHitbox.SetActive(false);
			}
			if (ClientVisualState.HitboxSpray)
			{
				Player.sprayHitbox.SetActive(true);
			}
			else
			{
				Player.sprayHitbox.SetActive(false);
			}
			Player.characterVisual.VFX.boostpackTrail.SetActive(ClientVisualState.BoostpackTrail);
			if (ClientVisualState.Disguised != PlayerComponent.HasPropDisguise)
			{
				if (!ClientVisualState.Disguised)
				{
					PlayerComponent.RemovePropDisguise();
				}
				else
				{
					PlayerComponent.ApplyPropDisguise(ClientVisualState.DisguiseId);
				}
			}
			else if (ClientVisualState.Disguised && PlayerComponent.DisguiseID != ClientVisualState.DisguiseId)
			{
				PlayerComponent.ApplyPropDisguise(ClientVisualState.DisguiseId);
			}
			if (PlayerComponent.HasPropDisguise)
			{
				PlayerComponent.DisguiseGameObject.transform.SetLocalPositionAndRotation(ClientVisualState.VisualPosition.ToUnityVector3(), ClientVisualState.VisualRotation.ToUnityQuaternion());
				PlayerComponent.DisguiseGameObject.transform.localScale = ClientVisualState.DisguiseScale.ToUnityVector3();
			}
			_previousState = ClientVisualState.State;
		}

		private void UpdateMoveStyleSkin()
		{
			if (ClientVisualState == null)
			{
				return;
			}
			_lastMoveStyleSkin = ClientVisualState.MoveStyleSkin;
			_lastMPMoveStyleSkin = ClientVisualState.MPMoveStyleSkin;
			if (ClientVisualState.MPMoveStyleSkin != -1)
			{
				if (MPUnlockManager.Instance.UnlockByID.ContainsKey(ClientVisualState.MPMoveStyleSkin))
				{
					(MPUnlockManager.Instance.UnlockByID[ClientVisualState.MPMoveStyleSkin] as MPMoveStyleSkin).ApplyToPlayer(Player);
				}
			}
			else
			{
				PlayerComponent.ApplyMoveStyleSkin(ClientVisualState.MoveStyleSkin);
			}
		}

		private void UpdateMoveStyle()
		{
			if ((Object)(object)Player == (Object)null)
			{
				return;
			}
			PlayerPatch.PlayAnimPatchEnabled = false;
			try
			{
				Player.SetCurrentMoveStyleEquipped((MoveStyle)ClientVisualState.MoveStyle, true, true);
				Player.SwitchToEquippedMovestyle(ClientVisualState.MoveStyleEquipped, false, true, false);
			}
			finally
			{
				PlayerPatch.PlayAnimPatchEnabled = true;
			}
		}

		[IteratorStateMachine(typeof(<UpdateMoveStyleDelayed>d__49))]
		private IEnumerator UpdateMoveStyleDelayed()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateMoveStyleDelayed>d__49(0)
			{
				<>4__this = this
			};
		}

		public void SetClientState(ClientState newClientState)
		{
			ClientState = newClientState;
		}

		public void UpdateNameplate()
		{
			//IL_006a: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			_ = ClientController.Instance;
			bool rival;
			bool num = InOurTeamLobby(out rival);
			CreateNameplateIfNecessary();
			string text = MPUtility.GetPlayerDisplayName(ClientState);
			if (num)
			{
				text = MPUtility.GetPlayerDisplayNameWithoutTags(ClientState);
				if (rival)
				{
					((Graphic)NamePlate.Label).color = Color.red;
				}
				else
				{
					((Graphic)NamePlate.Label).color = Color.green;
				}
			}
			else
			{
				((Graphic)NamePlate.Label).color = Color.white;
			}
			if (((TMP_Text)NamePlate.Label).text != text)
			{
				((TMP_Text)NamePlate.Label).text = text;
			}
		}

		private void CreateNameplateIfNecessary()
		{
			if ((Object)(object)NamePlate == (Object)null)
			{
				NamePlate = Nameplate.Create();
			}
		}

		private void TickUpdateNameplate()
		{
			_ = MPSettings.Instance;
			CreateNameplateIfNecessary();
		}

		private void UpdateSprayCan()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			if ((int)ClientVisualState.State == 1)
			{
				Player.characterVisual.SetSpraycan(true, (Characters)(-1));
			}
		}

		private void UpdateLookAt()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Player.characterVisual.lookAtVel = Player.GetPracticalWorldVelocity();
			Player.characterVisual.lookAtSubject = null;
			Player.characterVisual.phoneActive = false;
		}

		private void UpdatePhone()
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			if (ClientVisualState.PhoneHeld)
			{
				Player player = Player;
				player.phoneLayerWeight += Player.grabPhoneSpeed * Core.dt;
				Player.characterVisual.SetPhone(true);
				if (Player.phoneLayerWeight >= 1f)
				{
					Player.phoneLayerWeight = 1f;
					Player.characterVisual.phoneActive = true;
					Player.characterVisual.lookAtSubject = Player.characterVisual.VFX.phone;
					Player.characterVisual.lookAtPos = Vector3.Lerp(Player.characterVisual.lookAtPos, Player.characterVisual.VFX.phone.transform.position + Vector3.up * 0.25f, Mathf.Clamp(((Vector3)(ref Player.characterVisual.lookAtVel)).magnitude * Core.dt * 3f, 6f * Core.dt, 1f));
				}
			}
			else
			{
				Player player2 = Player;
				player2.phoneLayerWeight -= Player.grabPhoneSpeed * Core.dt;
				if (Player.phoneLayerWeight <= 0f)
				{
					Player.phoneLayerWeight = 0f;
					Player.characterVisual.SetPhone(false);
				}
			}
			Player.anim.SetLayerWeight(3, Player.phoneLayerWeight);
		}

		private void DeletePlayer()
		{
			ClearOptimizationActions();
			ClientController instance = ClientController.Instance;
			WorldHandler instance2 = WorldHandler.instance;
			Mapcontroller instance3 = Mapcontroller.Instance;
			if ((Object)(object)_mapPin != (Object)null)
			{
				instance3.m_MapPins.Remove(_mapPin);
				_mapPin.isMapPinValid = false;
				_mapPin.DisableMapPinGameObject();
				Object.Destroy((Object)(object)((Component)_mapPin).gameObject);
				Object.Destroy((Object)(object)_mapPinMaterial);
			}
			if ((Object)(object)Player != (Object)null)
			{
				instance?.MultiplayerPlayerByPlayer?.Remove(Player);
				if (instance2 != null)
				{
					instance2.SceneObjectsRegister?.players?.Remove(Player);
				}
				Object.Destroy((Object)(object)((Component)Player).gameObject);
				Player = null;
			}
		}

		public void Delete()
		{
			ClientState = null;
			ClientVisualState = null;
			if ((Object)(object)NamePlate != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)NamePlate).gameObject);
			}
			NamePlate = null;
			DeletePlayer();
		}
	}
	[BepInPlugin("BombRushMP.Plugin", "BombRushMP.Plugin", "1.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class MPPlugin : BaseUnityPlugin
	{
		private string _localAdminKey = Guid.NewGuid().ToString();

		private bool _selfHosting;

		private bool _offline;

		private ServerController _localServerController;

		private Dictionary<string, string> _themePaths = new Dictionary<string, string>();

		private void RegisterThemes(string path)
		{
			string[] directories = Directory.GetDirectories(path, "*", SearchOption.TopDirectoryOnly);
			foreach (string text in directories)
			{
				string fileName = Path.GetFileName(text);
				_themePaths[fileName] = text;
			}
		}

		private Theme LoadTheme(string themePath)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			Theme val = new Theme();
			ThemeConfig val2 = JsonConvert.DeserializeObject<ThemeConfig>(File.ReadAllText(Path.Combine(themePath, "theme.json")));
			val.ParseConfig(val2);
			string path = Path.Combine(themePath, "greticle.png");
			if (File.Exists(path))
			{
				Texture2D val3 = new Texture2D(2, 2);
				ImageConversion.LoadImage(val3, File.ReadAllBytes(path), true);
				val.GraffitiReticle = val3;
			}
			return val;
		}

		private void Awake()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Expected O, but got Unknown
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Expected O, but got Unknown
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Expected O, but got Unknown
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Expected O, but got Unknown
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Expected O, but got Unknown
			new MPSettings(((BaseUnityPlugin)this).Config, Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), Path.Combine(Paths.ConfigPath, "BombRushMP.Plugin"));
			string path = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "themes");
			string path2 = Path.Combine(Paths.ConfigPath, "BombRushMP.Plugin", "themes");
			Directory.CreateDirectory(path);
			Directory.CreateDirectory(path2);
			RegisterThemes(path);
			RegisterThemes(path2);
			string key = MPSettings.Instance.Theme;
			if (!_themePaths.ContainsKey(key))
			{
				key = "Default";
			}
			Theme.CurrentTheme = LoadTheme(_themePaths[key]);
			NetworkingEnvironment.UseNativeSocketsIfAvailable = MPSettings.Instance.UseNativeSockets;
			NetworkingEnvironment.NetworkingInterface = NetworkInterfaceFactory.GetNetworkInterface(MPSettings.Instance.NetworkInterface);
			NetworkingEnvironment.LogEventHandler = (Action<string>)Delegate.Combine(NetworkingEnvironment.LogEventHandler, (Action<string>)delegate(string log)
			{
				ClientLogger.Log("[NetworkingEnvironment] " + log);
			});
			NetworkingEnvironment.NetworkingInterface.MaxPayloadSize = 10000;
			_offline = MPSettings.Instance.Offline;
			_selfHosting = MPSettings.Instance.HostServer;
			ushort maxPlayers = MPSettings.Instance.MaxPlayers;
			if (_offline)
			{
				_selfHosting = true;
				maxPlayers = 1;
				NetworkingEnvironment.NetworkingInterface = (INetworkingInterface)(object)new BombRushMP.Plugin.OfflineInterface.OfflineInterface();
			}
			if (_selfHosting)
			{
				_localServerController = new ServerController(MPSettings.Instance.ServerPort, 1f / MPSettings.Instance.TicksPerSecond, maxPlayers, _offline, new LocalServerDatabase(_localAdminKey));
			}
			new MPAssets(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location));
			if (Chainloader.PluginInfos.ContainsKey("CrewBoom"))
			{
				CrewBoomSupport.Initialize();
				CrewBoomStreamer.Initialize();
				string text = Path.Combine(Paths.ConfigPath, "CrewBoom");
				string text2 = Path.Combine(Paths.ConfigPath, "BombRushMP.Plugin", "CrewBoom");
				Directory.CreateDirectory(text2);
				CrewBoomStreamer.AddDirectory(text2);
				CrewBoomStreamer.LoadCrewBoomConfigFolder(text);
			}
			if (Chainloader.PluginInfos.ContainsKey("MapStation.Plugin"))
			{
				MapStationSupport.Initialize();
			}
			if (Chainloader.PluginInfos.ContainsKey("goatgirl.NetRadio"))
			{
				NetRadioSupport.Initialize();
			}
			if (Chainloader.PluginInfos.ContainsKey("com.Dragsun.BunchOfEmotes"))
			{
				BunchOfEmotesSupport.Initialize();
			}
			ProxyEncounter.Initialize();
			InitializePhone();
			PacketFactory.Initialize();
			new SpecialSkinManager();
			new MPUnlockManager();
			new MPSaveData();
			Harmony val = new Harmony("BombRushMP.Plugin");
			val.PatchAll();
			InputPatch.Patch(val);
			StageManager.OnStageInitialized += new OnStageInitializedDelegate(StageManager_OnStageInitialized);
			StageManager.OnStagePostInitialization += new OnStageInitializedDelegate(StageManager_OnStagePostInitialization);
			ReflectionController.Initialize();
			StageAPI.OnStagePreInitialization = (StageInitializationDelegate)Delegate.Combine((Delegate?)(object)StageAPI.OnStagePreInitialization, (Delegate?)new StageInitializationDelegate(OnStagePreInitialization));
			InitShared();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin BombRushMP.Plugin is loaded!");
		}

		private void InitShared()
		{
			SharedUtils.SetLocalCharacter = (Action<Characters>)Delegate.Combine(SharedUtils.SetLocalCharacter, (Action<Characters>)delegate(Characters ch)
			{
				//IL_000f: 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)
				int outfit = Core.Instance.SaveManager.CurrentSaveSlot.GetCharacterProgress(ch).outfit;
				Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
				SpecialSkinManager.Instance.RemoveSpecialSkinFromPlayer(currentPlayer);
				currentPlayer.SetCharacter(ch, outfit);
				currentPlayer.InitVisual();
				Core.Instance.SaveManager.SaveCurrentSaveSlot();
			});
			SharedUtils.SetLocalSpecialSkin = (Action<SpecialSkins>)Delegate.Combine(SharedUtils.SetLocalSpecialSkin, (Action<SpecialSkins>)delegate(SpecialSkins skin)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				SpecialSkinManager.Instance.ApplySpecialSkinToPlayer(WorldHandler.instance.GetCurrentPlayer(), skin);
			});
		}

		private void OnStagePreInitialization(Stage newStage, Stage previousStage)
		{
			if (MPUtility.IsChristmas())
			{
				XmasController.Create();
			}
		}

		private void StageManager_OnStageInitialized()
		{
			if (CrewBoomSupport.Installed)
			{
				CrewBoomStreamer.ReloadResources();
				if (MPSettings.Instance.ReloadCharactersInLoadingScreens || !CrewBoomStreamer.AlreadyLoadedThisSession)
				{
					CrewBoomStreamer.ReloadCharacters();
				}
			}
			PropDisguiseController.Create();
		}

		private void Update()
		{
			CrewBoomStreamer.Tick();
		}

		private void InitializePhone()
		{
			AppMultiplayerBan.Initialize();
			AppGamemodeSettings.Initialize();
			AppMultiplayer.Initialize();
			AppMultiplayerDebug.Initialize();
			AppJoinLobbyDebug.Initialize();
			AppMultiplayerCurrentLobby.Initialize();
			AppMultiplayerStages.Initialize();
			AppMultiplayerBaseStages.Initialize();
			AppMultiplayerCustomStages.Initialize();
			AppMultiplayerLobbyInvite.Initialize();
			AppMultiplayerInvites.Initialize();
			AppMultiplayerAcceptInvite.Initialize();
			AppMultiplayerLobbyKick.Initialize();
			MoveStylePickerApp.Initialize();
			MoveStyleSkinPickerApp.Initialize();
			AppMultiplayerSwitchPlayerTeams.Initialize();
			AppMultiplayerPublicLobbies.Initialize();
		}

		private void StageManager_OnStagePostInitialization()
		{
			string address = MPSettings.Instance.ServerAddress;
			string authKey = MPSettings.Instance.AuthKey;
			if (_selfHosting)
			{
				address = "localhost";
				authKey = _localAdminKey;
			}
			ClientController.Create(address, MPSettings.Instance.ServerPort);
			ClientController.Instance.AuthKey = authKey;
			LobbyUI.Create();
			PlayerListUI.Create();
			TimerUI.Create();
			MPMapController.Create();
			NotificationController.Create();
			ChatUI.Create();
			BalanceUI.Create();
			StatsUI.Create();
			if (MPSettings.Instance.DebugInfo)
			{
				DebugUI.Create();
			}
		}
	}
	public class MPSaveData : CustomSaveData
	{
		public class MPCharacterData
		{
			public int MPMoveStyleSkin = -1;
		}

		private const byte Version = 3;

		public Dictionary<Characters, MPCharacterData> CharacterData = new Dictionary<Characters, MPCharacterData>();

		public Dictionary<string, MPCharacterData> CrewBoomCharacterData = new Dictionary<string, MPCharacterData>();

		public Dictionary<GamemodeIDs, SavedGamemodeSettings> GamemodeSettings = new Dictionary<GamemodeIDs, SavedGamemodeSettings>();

		public MPStats Stats = new MPStats();

		public bool UnlockedGoonieBoard;

		public bool PropHuntPlaytester;

		public static MPSaveData Instance { get; private set; }

		public MPSaveData()
			: base("BRCMP", "saveSlot{0}.sav", (SaveLocations)2)
		{
			Instance = this;
		}

		public override void Initialize()
		{
			CharacterData = new Dictionary<Characters, MPCharacterData>();
			CrewBoomCharacterData = new Dictionary<string, MPCharacterData>();
			GamemodeSettings = new Dictionary<GamemodeIDs, SavedGamemodeSettings>();
			Stats = new MPStats();
			UnlockedGoonieBoard = false;
			PropHuntPlaytester = false;
		}

		public SavedGamemodeSettings GetSavedSettings(GamemodeIDs gamemode)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (GamemodeSettings.TryGetValue(gamemode, out var value))
			{
				return value;
			}
			return null;
		}

		public override void Read(BinaryReader reader)
		{
			//IL_00b2: 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)
			byte b = reader.ReadByte();
			if (b > 3)
			{
				base.FailedToLoad = true;
				return;
			}
			UnlockedGoonieBoard = reader.ReadBoolean();
			int num = reader.ReadInt32();
			for (int i = 0; i < num; i++)
			{
				int num2 = reader.ReadInt32();
				int mPMoveStyleSkin = reader.ReadInt32();
				CharacterData[(Characters)num2] = new MPCharacterData
				{
					MPMoveStyleSkin = mPMoveStyleSkin
				};
			}
			num = reader.ReadInt32();
			for (int j = 0; j < num; j++)
			{
				string key = reader.ReadString();
				int mPMoveStyleSkin2 = reader.ReadInt32();
				CrewBoomCharacterData[key] = new MPCharacterData
				{
					MPMoveStyleSkin = mPMoveStyleSkin2
				};
			}
			if (b > 0)
			{
				int num3 = reader.ReadInt32();
				for (int k = 0; k < num3; k++)
				{
					GamemodeIDs key2 = (GamemodeIDs)reader.ReadInt32();
					SavedGamemodeSettings savedGamemodeSettings = new SavedGamemodeSettings();
					savedGamemodeSettings.Read(reader);
					GamemodeSettings[key2] = savedGamemodeSettings;
				}
			}
			if (b > 1)
			{
				Stats.Read(reader);
			}
			if (b > 2)
			{
				PropHuntPlaytester = reader.ReadBoolean();
			}
		}

		public override void Write(BinaryWriter writer)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected I4, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected I4, but got Unknown
			writer.Write((byte)3);
			writer.Write(UnlockedGoonieBoard);
			writer.Write(CharacterData.Count);
			foreach (KeyValuePair<Characters, MPCharacterData> characterDatum in CharacterData)
			{
				writer.Write((int)characterDatum.Key);
				writer.Write(characterDatum.Value.MPMoveStyleSkin);
			}
			writer.Write(CrewBoomCharacterData.Count);
			foreach (KeyValuePair<string, MPCharacterData> crewBoomCharacterDatum in CrewBoomCharacterData)
			{
				writer.Write(crewBoomCharacterDatum.Key);
				writer.Write(crewBoomCharacterDatum.Value.MPMoveStyleSkin);
			}
			writer.Write(GamemodeSettings.Count);
			foreach (KeyValuePair<GamemodeIDs, SavedGamemodeSettings> gamemodeSetting in GamemodeSettings)
			{
				writer.Write((int)gamemodeSetting.Key);
				gamemodeSetting.Value.Write(writer);
			}
			Stats.Write(writer);
			writer.Write(PropHuntPlaytester);
		}

		public MPCharacterData GetCharacterData(Characters character)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			bool justCreated;
			return GetCharacterData(character, out justCreated);
		}

		public MPCharacterData GetCharacterData(Characters character, out bool justCreated)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0068: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			justCreated = false;
			if ((int)character >= 26)
			{
				Guid guidForCharacter = CrewBoomSupport.GetGuidForCharacter(character);
				if (!CrewBoomCharacterData.ContainsKey(guidForCharacter.ToString()))
				{
					justCreated = true;
					CrewBoomCharacterData[guidForCharacter.ToString()] = new MPCharacterData();
				}
				return CrewBoomCharacterData[guidForCharacter.ToString()];
			}
			if (!CharacterData.ContainsKey(character))
			{
				justCreated = true;
				CharacterData[character] = new MPCharacterData();
			}
			return CharacterData[character];
		}

		public bool ShouldDisplayGoonieBoard()
		{
			if (UnlockedGoonieBoard)
			{
				return true;
			}
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			AuthUser localUser = instance.GetLocalUser();
			if (localUser == null)
			{
				return false;
			}
			if (localUser.HasTag("elite"))
			{
				return true;
			}
			return false;
		}

		public void UnlockGoonieBoard()
		{
			UnlockedGoonieBoard = true;
			Core.Instance.SaveManager.SaveCurrentSaveSlot();
			ClientController.Instance.SendClientState();
		}
	}
	public class MPSettings
	{
		private const byte Version = 0;

		public Criteria ChatCriteria = new Criteria(new string[8] { "b", "color", "i", "mark", "s", "sub", "sup", "u" }, (Kinds)0);

		private ConfigEntry<ReflectionQualities> _reflectionQuality;

		private ConfigEntry<bool> _playerAudioEnabled;

		private ConfigEntry<bool> _playerDopplerEnabled;

		private ConfigEntry<string> _serverAddress;

		private ConfigEntry<string> _playerName;

		private ConfigEntry<string> _crewName;

		private ConfigEntry<int> _serverPort;

		private ConfigEntry<bool> _debugLocalPlayer;

		private ConfigEntry<bool> _showNamePlates;

		private ConfigEntry<bool> _showMinimap;

		private ConfigEntry<bool> _showNotifications;

		private ConfigEntry<bool> _leaveJoinMessages;

		private ConfigEntry<bool> _afkMessages;

		private ConfigEntry<bool> _inviteMessages;

		private ConfigEntry<bool> _showAFKEffects;

		private ConfigEntry<bool> _debugInfo;

		private ConfigEntry<KeyCode> _talkKey;

		private ConfigEntry<KeyCode> _chatKey;

		private ConfigEntry<KeyCode> _playerListKey;

		private ConfigEntry<KeyCode> _readyKey;

		private ConfigEntry<bool> _filterProfanity;

		private ConfigEntry<bool> _showChat;

		private ConfigEntry<BalanceUI.Types> _balanceUIType;

		private ConfigEntry<NetworkInterfaces> _networkInterface;

		private ConfigEntry<bool> _useNativeSockets;

		private ConfigEntry<bool> _hostServer;

		private ConfigEntry<float> _ticksPerSecond;

		private ConfigEntry<ushort> _maxPlayers;

		private ConfigEntry<bool> _offline;

		private string _authKey = "";

		private ConfigEntry<CharacterNames> _fallbackCharacter;

		private ConfigEntry<int> _fallbackOutfit;

		private ConfigEntry<bool> _invisible;

		private ConfigEntry<bool> _dontAutoScrollChatIfFocused;

		private ConfigEntry<bool> _deathMessages;

		private ConfigEntry<bool> _hidePlayersOutOfView;

		private ConfigEntry<bool> _hidePlayersInInactiveChunks;

		private ConfigEntry<float> _playerDrawDistance;

		private ConfigEntry<float> _playerLodDistance;

		private ConfigEntry<bool> _playerLodEnabled;

		private ConfigEntry<bool> _optimizeOnePlayerAtATime;

		private ConfigEntry<bool> _loadCharactersAsync;

		private ConfigEntry<bool> _reloadCharactersInLoadingScreens;

		private ConfigEntry<bool> _statsScreenMusic;

		private ConfigEntry<bool> _allowTeleports;

		private ConfigEntry<float> _chatFontSize;

		private ConfigEntry<bool> _deathSequence;

		private ConfigEntry<bool> _showBadges;

		private ConfigEntry<Gamemode.PlayerSort> _gamemodePlayerSort;

		private ConfigEntry<bool> _graceTimer;

		private ConfigEntry<bool> _smoothSprites;

		private ConfigEntry<string> _theme;

		private string _savePath;

		private ConfigFile _configFile;

		private const string General = "1. General";

		private const string Settings = "2. Settings";

		private const string ChatSettings = "3. Chat Settings";

		private const string Input = "4. Input";

		private const string Debug = "5. Debug";

		private const string Visuals = "6. Visuals";

		private const string Advanced = "7. Advanced";

		private const string Server = "8. Server";

		private const string Optimization = "9. Optimization";

		private const string CrewBoom = "10. CrewBoom";

		private const string Misc = "11. Misc";

		private const string MainServerAddress = "free.soulisall.city";

		public const string DefaultName = "Big Slopper";

		public static MPSettings Instance { get; private set; }

		public string Directory { get; private set; }

		public ReflectionQualities ReflectionQuality
		{
			get
			{
				return _reflectionQuality.Value;
			}
			set
			{
				_reflectionQuality.Value = value;
			}
		}

		public bool PlayerAudioEnabled
		{
			get
			{
				return _playerAudioEnabled.Value;
			}
			set
			{
				_playerAudioEnabled.Value = value;
			}
		}

		public bool PlayerDopplerEnabled
		{
			get
			{
				return _playerDopplerEnabled.Value;
			}
			set
			{
				_playerDopplerEnabled.Value = value;
			}
		}

		public string ServerAddress
		{
			get
			{
				return _serverAddress.Value;
			}
			set
			{
				_serverAddress.Value = value;
			}
		}

		public int ServerPort
		{
			get
			{
				return _serverPort.Value;
			}
			set
			{
				_serverPort.Value = value;
			}
		}

		public string PlayerName
		{
			get
			{
				string text = _playerName.Value;
				if (text.Length > 64)
				{
					text = text.Substring(0, 64);
				}
				return text;
			}
			set
			{
				_playerName.Value = value;
			}
		}

		public string CrewName
		{
			get
			{
				string text = _crewName.Value;
				if (text.Length > 32)
				{
					text = text.Substring(0, 32);
				}
				return text;
			}
			set
			{
				_crewName.Value = value;
			}
		}

		public bool ShowNamePlates
		{
			get
			{
				return _showNamePlates.Value;
			}
			set
			{
				_showNamePlates.Value = value;
			}
		}

		public bool ShowMinimap
		{
			get
			{
				return _showMinimap.Value;
			}
			set
			{
				_showMinimap.Value = value;
			}
		}

		public bool ShowNotifications
		{
			get
			{
				return _showNotifications.Value;
			}
			set
			{
				_showNotifications.Value = value;
			}
		}

		public bool LeaveJoinMessages
		{
			get
			{
				return _leaveJoinMessages.Value;
			}
			set
			{
				_leaveJoinMessages.Value = value;
			}
		}

		public bool ShowAFKEffects
		{
			get
			{
				return _showAFKEffects.Value;
			}
			set
			{
				_showAFKEffects.Value = value;
			}
		}

		public bool AFKMessages
		{
			get
			{
				return _afkMessages.Value;
			}
			set
			{
				_afkMessages.Value = value;
			}
		}

		public bool InviteMessages
		{
			get
			{
				return _inviteMessages.Value;
			}
			set
			{
				_inviteMessages.Value = value;
			}
		}

		public KeyCode TalkKey
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return _talkKey.Value;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				_talkKey.Value = value;
			}
		}

		public KeyCode ReadyKey
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return _readyKey.Value;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				_readyKey.Value = value;
			}
		}

		public KeyCode ChatKey
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return _chatKey.Value;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				_chatKey.Value = value;
			}
		}

		public bool FilterProfanity => true;

		public bool DebugLocalPlayer => false;

		public bool DebugInfo => false;

		public bool ShowChat
		{
			get
			{
				return _showChat.Value;
			}
			set
			{
				_showChat.Value = value;
			}
		}

		public NetworkInterfaces NetworkInterface
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return _networkInterface.Value;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				_networkInterface.Value = value;
			}
		}

		public BalanceUI.Types BalanceUIType
		{
			get
			{
				return _balanceUIType.Value;
			}
			set
			{
				_balanceUIType.Value = value;
			}
		}

		public bool UseNativeSockets
		{
			get
			{
				return _useNativeSockets.Value;
			}
			set
			{
				_useNativeSockets.Value = value;
			}
		}

		public bool HostServer
		{
			get
			{
				return _hostServer.Value;
			}
			set
			{
				_hostServer.Value = value;
			}
		}

		public float TicksPerSecond
		{
			get
			{
				return _ticksPerSecond.Value;
			}
			set
			{
				_ticksPerSecond.Value = value;
			}
		}

		public ushort MaxPlayers
		{
			get
			{
				return _maxPlayers.Value;
			}
			set
			{
				_maxPlayers.Value = value;
			}
		}

		public bool Offline
		{
			get
			{
				return _offline.Value;
			}
			set
			{
				_offline.Value = value;
			}
		}

		public string AuthKey
		{
			get
			{
				return _authKey;
			}
			set
			{
				_authKey = value;
			}
		}

		public CharacterNames FallbackCharacter
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return _fallbackCharacter.Value;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				_fallbackCharacter.Value = value;
			}
		}

		public int FallbackOutfit
		{
			get
			{
				return _fallbackOutfit.Value;
			}
			set
			{
				_fallbackOutfit.Value = value;
			}
		}

		public bool Invisible => false;

		public KeyCode PlayerListKey
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return _playerListKey.Value;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				_playerListKey.Value = value;
			}
		}

		public bool DontAutoScrollChatIfFocused
		{
			get
			{
				return _dontAutoScrollChatIfFocused.Value;
			}
			set
			{
				_dontAutoScrollChatIfFocused.Value = value;
			}
		}

		public bool DeathMessages
		{
			get
			{
				return _deathMessages.Value;
			}
			set
			{
				_deathMessages.Value = value;
			}
		}

		public bool HidePlayersOutOfView
		{
			get
			{
				return _hidePlayersOutOfView.Value;
			}
			set
			{
				_hidePlayersOutOfView.Value = value;
			}
		}

		public float PlayerDrawDistance
		{
			get
			{
				return _playerDrawDistance.Value;
			}
			set
			{
				_playerDrawDistance.Value = value;
			}
		}

		public float PlayerLodDistance
		{
			get
			{
				return _playerLodDistance.Value;
			}
			set
			{
				_playerLodDistance.Value = value;
			}
		}

		public bool PlayerLodEnabled
		{
			get
			{
				return _playerLodEnabled.Value;
			}
			set
			{
				_playerLodEnabled.Value = value;
			}
		}

		public bool HidePlayersInInactiveChunks
		{
			get
			{
				return _hidePlayersInInactiveChunks.Value;
			}
			set
			{
				_hidePlayersInInactiveChunks.Value = value;
			}
		}

		public bool OptimizeOnePlayerAtATime
		{
			get
			{
				return _optimizeOnePlayerAtATime.Value;
			}
			set
			{
				_optimizeOnePlayerAtATime.Value = value;
			}
		}

		public bool LoadCharactersAsync
		{
			get
			{
				return _loadCharactersAsync.Value;
			}
			set
			{
				_loadCharactersAsync.Value = value;
			}
		}

		public bool ReloadCharactersInLoadingScreens
		{
			get
			{
				return _reloadCharactersInLoadingScreens.Value;
			}
			set
			{
				_reloadCharactersInLoadingScreens.Value = value;
			}
		}

		public bool StatsScreenMusic
		{
			get
			{
				return _statsScreenMusic.Value;
			}
			set
			{
				_statsScreenMusic.Value = value;
			}
		}

		public bool AllowTeleports
		{
			get
			{
				return _allowTeleports.Value;
			}
			set
			{
				_allowTeleports.Value = value;
			}
		}

		public float ChatFontSize
		{
			get
			{
				return _chatFontSize.Value;
			}
			set
			{
				_chatFontSize.Value = value;
			}
		}

		public bool DeathSequence
		{
			get
			{
				return _deathSequence.Value;
			}
			set
			{
				_deathSequence.Value = value;
			}
		}

		public bool ShowBadges
		{
			get
			{
				return _showBadges.Value;
			}
			set
			{
				_showBadges.Value = value;
			}
		}

		public bool GraceTimer
		{
			get
			{
				return _graceTimer.Value;
			}
			set
			{
				_graceTimer.Value = value;
			}
		}

		public Gamemode.PlayerSort GamemodePlayerSort
		{
			get
			{
				return _gamemodePlayerSort.Value;
			}
			set
			{
				_gamemodePlayerSort.Value = value;
			}
		}

		public bool SmoothSprites
		{
			get
			{
				return _smoothSprites.Value;
			}
			set
			{
				_smoothSprites.Value = value;
			}
		}

		public string Theme
		{
			get
			{
				return _theme.Value;
			}
			set
			{
				_theme.Value = value;
			}
		}

		public float SpriteBaseline => 0.8f;

		public MPSettings(ConfigFile configFile, string dir, string configPath)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			Directory = dir;
			Instance = this;
			_configFile = configFile;
			string path = Path.Combine(configPath, "auth.txt");
			System.IO.Directory.CreateDirectory(configPath);
			if (!File.Exists(path))
			{
				File.Create(path);
			}
			else
			{
				_authKey = TMPFilter.Sanitize(File.ReadAllText(path));
			}
			_reflectionQuality = configFile.Bind<ReflectionQualities>("2. Settings", "Reflection Quality", ReflectionQualities.High, "Quality of reflections on reflective surfaces.");
			_playerName = configFile.Bind<string>("1. General", "Player Name", "Big Slopper", "Your player name.");
			_playerName.SettingChanged += delegate
			{
				ClientController.Instance.InfrequentClientStateUpdateQueued = true;
			};
			_showBadges = configFile.Bind<bool>("1. General", "Show Badges", true, "Whether to display your badges before your name, if you have any.");
			_showBadges.SettingChanged += delegate
			{
				ClientController.Instance.InfrequentClientStateUpdateQueued = true;
			};
			_crewName = configFile.Bind<string>("1. General", "Crew Name", "", "Name of your crew.");
			_crewName.SettingChanged += delegate
			{
				ClientController.Instance.InfrequentClientStateUpdateQueued = true;
			};
			_allowTeleports = configFile.Bind<bool>("2. Settings", "Allow Players to Teleport to you", true, "Whether to allow spectators to teleport to you.");
			_allowTeleports.SettingChanged += delegate
			{
				ClientController.Instance.InfrequentClientStateUpdateQueued = true;
			};
			_chatFontSize = configFile.Bind<float>("3. Chat Settings", "Chat Font Size", 25f, "Size of the chat font.");
			_chatFontSize.SettingChanged += delegate
			{
				ChatUI instance = ChatUI.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.UpdateSizes();
				}
			};
			_serverAddress = configFile.Bind<string>("1. General", "Server Address", "free.soulisall.city", "Address of the server to connect to.");
			_serverPort = configFile.Bind<int>("1. General", "Server Port", 41585, "Port of the server to connect to.");
			_statsScreenMusic = configFile.Bind<bool>("2. Settings", "Stats Screen Music", true, "Play music when viewing the Stats screen.");
			_playerAudioEnabled = configFile.Bind<bool>("2. Settings", "Player Voices Enabled", true, "Whether to enable voices for other players' actions.");
			_playerDopplerEnabled = configFile.Bind<bool>("2. Settings", "Player Audio Doppler", false, "Whether to enable the doppler effect on other players' sound effects.");
			_showNamePlates = configFile.Bind<bool>("2. Settings", "Show Nameplates", true, "Whether to show nameplates above players.");
			_showMinimap = configFile.Bind<bool>("2. Settings", "Show Minimap", true, "Whether to always show the minimap in-game.");
			_showNotifications = configFile.Bind<bool>("2. Settings", "Show Notifications", true, "Whether to show notifications when you're invited to a lobby.");
			_showAFKEffects = configFile.Bind<bool>("2. Settings", "Show AFK Effects on Players", true, "Whether to render sleeping Z's on AFK players.");
			_leaveJoinMessages = configFile.Bind<bool>("3. Chat Settings", "Show Player Join/Leave Messages", true, "Whether to show player join/leave messages in chat.");
			_afkMessages = configFile.Bind<bool>("3. Chat Settings", "Show Player AFK Messages", true, "Whether to show a message in chat when a player goes AFK.");
			_inviteMessages = configFile.Bind<bool>("3. Chat Settings", "Show Lobby Invite Messages", true, "Whether to show a message in chat when you're invited to a lobby.");
			_talkKey = configFile.Bind<KeyCode>("4. Input", "Talk Key", (KeyCode)104, "Press this key to make your character talk.");
			_chatKey = configFile.Bind<KeyCode>("4. Input", "Chat Key", (KeyCode)9, "Press this key to open the chat.");
			_readyKey = configFile.Bind<KeyCode>("4. Input", "(Lobby) Ready Key", (KeyCode)114, "Press this key to toggle ready when in a lobby.");
			_playerListKey = configFile.Bind<KeyCode>("4. Input", "Player List Key", (KeyCode)106, "Press this key to toggle the player list.");
			_showChat = configFile.Bind<bool>("3. Chat Settings", "Show Chat", true, "Whether to display the chat.");
			_dontAutoScrollChatIfFocused = configFile.Bind<bool>("3. Chat Settings", "No auto scroll chat if focused", false, "If true, will not scroll to the bottom when messages are received if the chat window is open for typing/scrolling.");
			_balanceUIType = configFile.Bind<BalanceUI.Types>("6. Visuals", "Balance UI", BalanceUI.Types.TypeC, "Balance UI theme.");
			_gamemodePlayerSort = configFile.Bind<Gamemode.PlayerSort>("6. Visuals", "Lobby Player List Sort", Gamemode.PlayerSort.Score, "Whether to sort the lobby player list by last score or by total wins.");
			_graceTimer = configFile.Bind<bool>("6. Visuals", "Graffiti Race Timer", true, "If true, will display a timer during Graffiti Races.");
			_networkInterface = configFile.Bind<NetworkInterfaces>("7. Advanced", "Network Interface", (NetworkInterfaces)1, "Networking library to use. Should match the server.");
			_useNativeSockets = configFile.Bind<bool>("7. Advanced", "Use Native Sockets", true, "Whether the networking library should use native sockets if available. Potentially better performance. Currently only supported via LiteNetLib networking.");
			_useNativeSockets.SettingChanged += delegate
			{
				NetworkingEnvironment.UseNativeSocketsIfAvailable = UseNativeSockets;
			};
			_hostServer = configFile.Bind<bool>("8. Server", "Host Server", false, "Host a local server.");
			_ticksPerSecond = configFile.Bind<float>("8. Server", "Ticks per second", 32f, "Networking updates per second for local server.");
			_maxPlayers = configFile.Bind<ushort>("8. Server", "Max players", (ushort)64, "Max players for local server.");
			_offline = configFile.Bind<bool>("1. General", "Offline", false, "Run All City Network in singleplayer, offline mode.");
			_fallbackCharacter = configFile.Bind<CharacterNames>("1. General", "Fallback Character", (CharacterNames)3, "Character to display to other players when you're using a CrewBoom character they don't have.");
			_fallbackCharacter.SettingChanged += delegate
			{
				ClientController.Instance.InfrequentClientStateUpdateQueued = true;
			};
			_fallbackOutfit = configFile.Bind<int>("1. General", "Fallback Character Outfit", 0, "Outfit number to use for your fallback character.");
			_fallbackOutfit.SettingChanged += delegate
			{
				ClientController.Instance.InfrequentClientStateUpdateQueued = true;
			};
			_deathMessages = configFile.Bind<bool>("3. Chat Settings", "Show Player Death Messages", true, "Whether to send messages in chat when players die.");
			_hidePlayersOutOfView = configFile.Bind<bool>("9. Optimization", "Cull Players out of view", false, "Whether to cull players that are out of view, to save on resources.");
			_playerDrawDistance = configFile.Bind<float>("9. Optimization", "Player draw distance", 20000f, "Distance at which players will be hidden to save on resources.");
			_playerLodEnabled = configFile.Bind<bool>("9. Optimization", "Player LOD enabled", false, "Whether to reduce player quality at a certain distance.");
			_playerLodDistance = configFile.Bind<float>("9. Optimization", "Player LOD distance", 2500f, "Distance at which players will render at a lower quality to save on resources.");
			_hidePlayersInInactiveChunks = configFile.Bind<bool>("9. Optimization", "Cull Players in inactive chunks", false, "Whether to cull players that are at culled stage chunks to save on resources.");
			_optimizeOnePlayerAtATime = configFile.Bind<bool>("9. Optimization", "Optimize one Player at a time", true, "Only update visibility and LODs for one player at a time, to avoid stutters.");
			_loadCharactersAsync = configFile.Bind<bool>("10. CrewBoom", "Load Characters Async", true, "Loads characters from your ACN CrewBoom folder asynchronously to prevent stutters.");
			_reloadCharactersInLoadingScreens = configFile.Bind<bool>("10. CrewBoom", "Reload Characters", true, "Reloads your CrewBoom folder during loading screens in between stages. Allows you to add new characters at runtime.");
			_deathSequence = configFile.Bind<bool>("11. Misc", "Death Sequence", true, "Whether to play the death sequence when you die.");
			_smoothSprites = configFile.Bind<bool>("6. Visuals", "Smooth Sprites", true, "Whether to smooth out emojis and badges on render.");
			_smoothSprites.SettingChanged += delegate
			{
				MPAssets.Instance.Sprites.spriteSheet.filterMode = (FilterMode)(SmoothSprites ? 1 : 0);
			};
			_theme = configFile.Bind<string>("6. Visuals", "Theme", "Default", "Name of the theme to use. Will look in plugin/(plugin)/themes and config/BombRushMP.Plugin/themes");
		}

		public void Save()
		{
			_configFile.Save();
		}
	}
	public class MPSkateboardSkin : MPMoveStyleSkin
	{
		public Mesh SkateboardMesh;

		public override MoveStyle MoveStyle => (MoveStyle)2;

		public MPSkateboardSkin(string title, string howToUnlock, int id, bool unlockedByDefault, Texture texture, Mesh mesh = null)
			: base(title, howToUnlock, id, unlockedByDefault, texture, null)
		{
			SkateboardMesh = mesh;
		}

		public MPSkateboardSkin(string title, string howToUnlock, int id, bool unlockedByDefault, Material material, Mesh mesh = null)
			: base(title, howToUnlock, id, unlockedByDefault, null, (Material[])(object)new Material[1] { material })
		{
			SkateboardMesh = mesh;
		}

		public MPSkateboardSkin(string title, string howToUnlock, int id, bool unlockedByDefault, Material[] materials, Mesh mesh = null)
			: base(title, howToUnlock, id, unlockedByDefault, null, materials)
		{
			SkateboardMesh = mesh;
		}

		public override void ApplyToPlayer(Player player)
		{
			base.ApplyToPlayer(player);
			Mesh val = SkateboardMesh;
			if ((Object)(object)val == (Object)null)
			{
				val = player.MoveStylePropsPrefabs.skateboard.GetComponent<MeshFilter>().sharedMesh;
			}
			player.characterVisual.moveStyleProps.skateboard.GetComponent<MeshFilter>().sharedMesh = val;
			ReflectionController instance = ReflectionController.Instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)instance.Probe != (Object)null)
			{
				((Renderer)player.characterVisual.moveStyleProps.skateboard.GetComponent<MeshRenderer>()).probeAnchor = instance.Anchor;
			}
		}
	}
	public class MPStats
	{
		private const byte Version = 1;

		public uint ElitesPlayedAgainst;

		public uint ElitesBeaten;

		public uint TimesFallenAsleep;

		public double TimeSpentAsleep;

		public double TimeSpentSpectating;

		public uint PlayersHit;

		public uint TimesHit;

		public uint Deaths;

		public uint TimesSaidHello;

		public Dictionary<GamemodeIDs, uint> GamemodesPlayed = new Dictionary<GamemodeIDs, uint>();

		public Dictionary<GamemodeIDs, uint> GamemodesWon = new Dictionary<GamemodeIDs, uint>();

		public Dictionary<GamemodeIDs, uint> GamemodesPlayedAlone = new Dictionary<GamemodeIDs, uint>();

		public void IncreaseGamemodesPlayed(GamemodeIDs gamemode)
		{
			//IL_0008: 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)
			uint num = 0u;
			if (GamemodesPlayed.TryGetValue(gamemode, out var value))
			{
				num = value;
			}
			num++;
			GamemodesPlayed[gamemode] = num;
		}

		public void IncreaseGamemodesWon(GamemodeIDs gamemode)
		{
			//IL_0008: 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)
			uint num = 0u;
			if (GamemodesWon.TryGetValue(gamemode, out var value))
			{
				num = value;
			}
			num++;
			GamemodesWon[gamemode] = num;
		}

		public void IncreaseGamemodesPlayedAlone(GamemodeIDs gamemode)
		{
			//IL_0008: 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)
			uint num = 0u;
			if (GamemodesPlayedAlone.TryGetValue(gamemode, out var value))
			{
				num = value;
			}
			num++;
			GamemodesPlayedAlone[gamemode] = num;
		}

		public void Write(BinaryWriter writer)
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected I4, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected I4, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected I4, but got Unknown
			writer.Write((byte)1);
			writer.Write(ElitesPlayedAgainst);
			writer.Write(ElitesBeaten);
			writer.Write(TimesFallenAsleep);
			writer.Write(TimeSpentAsleep);
			writer.Write(TimeSpentSpectating);
			writer.Write(PlayersHit);
			writer.Write(TimesHit);
			writer.Write(Deaths);
			writer.Write(TimesSaidHello);
			writer.Write(GamemodesPlayed.Count);
			foreach (KeyValuePair<GamemodeIDs, uint> item in GamemodesPlayed)
			{
				writer.Write((int)item.Key);
				writer.Write(item.Value);
			}
			writer.Write(GamemodesWon.Count);
			foreach (KeyValuePair<GamemodeIDs, uint> item2 in GamemodesWon)
			{
				writer.Write((int)item2.Key);
				writer.Write(item2.Value);
			}
			writer.Write(GamemodesPlayedAlone.Count);
			foreach (KeyValuePair<GamemodeIDs, uint> item3 in GamemodesPlayedAlone)
			{
				writer.Write((int)item3.Key);
				writer.Write(item3.Value);
			}
		}

		public void Read(BinaryReader reader)
		{
			byte b = reader.ReadByte();
			ElitesPlayedAgainst = reader.ReadUInt32();
			ElitesBeaten = reader.ReadUInt32();
			TimesFallenAsleep = reader.ReadUInt32();
			TimeSpentAsleep = reader.ReadDouble();
			TimeSpentSpectating = reader.ReadDouble();
			PlayersHit = reader.ReadUInt32();
			TimesHit = reader.ReadUInt32();
			Deaths = reader.ReadUInt32();
			TimesSaidHello = reader.ReadUInt32();
			int num = reader.ReadInt32();
			for (int i = 0; i < num; i++)
			{
				int num2 = reader.ReadInt32();
				uint value = reader.ReadUInt32();
				GamemodesPlayed[(GamemodeIDs)num2] = value;
			}
			int num3 = reader.ReadInt32();
			for (int j = 0; j < num3; j++)
			{
				int num4 = reader.ReadInt32();
				uint value2 = reader.ReadUInt32();
				GamemodesWon[(GamemodeIDs)num4] = value2;
			}
			if (b > 0)
			{
				int num5 = reader.ReadInt32();
				for (int k = 0; k < num5; k++)
				{
					int num6 = reader.ReadInt32();
					uint value3 = reader.ReadUInt32();
					GamemodesPlayedAlone[(GamemodeIDs)num6] = value3;
				}
			}
		}
	}
	public class MPUnlockable
	{
		public int Identifier = -1;

		public bool UnlockedByDefault = true;

		public MPUnlockable(int id, bool unlockedByDefault = true)
		{
			Identifier = id;
			UnlockedByDefault = unlockedByDefault;
		}
	}
	public class MPUnlockManager
	{
		public Dictionary<int, MPUnlockable> UnlockByID = new Dictionary<int, MPUnlockable>();

		public static MPUnlockManager Instance { get; private set; }

		public MPUnlockManager()
		{
			Instance = this;
			RegisterUnlock(new MPSkateboardSkin("Freesoul", "By: Pupsi", Animator.StringToHash("freesoulskateboard"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("FreesoulSkateboardTex"), GetMeshFromAssets("FreesoulSkateboardMesh")));
			RegisterUnlock(new MPSkateboardSkin("Dreamcast", "By: Pupsi", Animator.StringToHash("dreamcastskateboard"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("DreamcastSkateboardTex")));
			RegisterUnlock(new MPSkateboardSkin("Knuckles", "By: Pupsi", Animator.StringToHash("knucklesskateboard"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("KnucklesSkateboardTex")));
			RegisterUnlock(new MPSkateboardSkin("Moe Shop", "By: Pupsi", Animator.StringToHash("moeshopskateboard"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("MoeShopSkateboardTex")));
			RegisterUnlock(new MPSkateboardSkin("Glassboard", "By: Woodztock", Animator.StringToHash("glassboardskateboard"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("cottoncandy"), GetMeshFromAssets("GlassboardMesh")));
			RegisterUnlock(new MPSkateboardSkin("Iced Board", "By: Stony", Animator.StringToHash("icedboardskateboard"), unlockedByDefault: true, GetMaterialFromAssets("IcedBoardMat"), GetMeshFromAssets("IcedBoard")));
			RegisterUnlock(new MPSkateboardSkin("Crystal Board", "By: Woodztock", Animator.StringToHash("crystalboardskateboard"), unlockedByDefault: true, GetMaterialFromAssets("CrystalBoardMat"), GetMeshFromAssets("CrystalBoardMesh")));
			RegisterUnlock(new MPSkateboardSkin("Goonie", "By: Pupsi", Animator.StringToHash("goonieskateboard"), unlockedByDefault: true, (Material[])(object)new Material[6]
			{
				GetMaterialFromAssets("GoonieEmerald"),
				GetMaterialFromAssets("GoonieMetal"),
				GetMaterialFromAssets("GoonieGold"),
				GetMaterialFromAssets("GoonieEmission"),
				GetMaterialFromAssets("GoonieGold2"),
				GetMaterialFromAssets("GoonieOutline")
			}, GetMeshFromAssets("GoonieMesh")));
			RegisterUnlock(new MPSkateboardSkin("GWMA", "By: Yoshi", Animator.StringToHash("gwmaskateboard"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("GWMASkateboardTex")));
			RegisterUnlock(new MPSkateboardSkin("BAKER", "By: Fay", Animator.StringToHash("bakerskateboard"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("BAKERSkateboardTex")));
			RegisterUnlock(new MPSkateboardSkin("Smash", "By: Fay", Animator.StringToHash("smashskateboard"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("SmashSkateboardTex")));
			RegisterUnlock(new MPSkateboardSkin("Aqua", "By: Fay", Animator.StringToHash("aquaskateboard"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("AquaSkateboardTex")));
			RegisterUnlock(new MPSkateboardSkin("Rave", "By: Undad", Animator.StringToHash("raveskateboard"), unlockedByDefault: true, GetMaterialFromAssets("RaveboardMat"), GetMeshFromAssets("RaveboardMesh")));
			RegisterUnlock(new MPSkateboardSkin("Futurism", "By: Kris The Fox and Stony", Animator.StringToHash("fismboard"), unlockedByDefault: true, GetMaterialFromAssets("fismboardMat"), GetMeshFromAssets("fismboardMesh")));
			RegisterUnlock(new MPSkateboardSkin("Candyman", "By: Hellfiend", Animator.StringToHash("candymanboard"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("CandymanBoard")));
			RegisterUnlock(new MPSkateboardSkin("enjoi", "cute cats", Animator.StringToHash("enjoiboard"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("EnjoiSkateboardTex")));
			RegisterUnlock(new MPSkateboardSkin("Cherry Blossom Bomber Barbara", "By: LadyAnn45 and Woodztock", Animator.StringToHash("cbbbboard"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("cbbTex"), GetMeshFromAssets("cbbBoard")));
			RegisterUnlock(new MPSkateboardSkin("Slice of Life", "By: Kogey", Animator.StringToHash("pizzadeck"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("pizzadeck"), GetMeshFromAssets("pizza")));
			RegisterUnlock(new MPSkateboardSkin("Goonie (Real)", "By: Keziah_L", Animator.StringToHash("realgoonie"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("goonietex"), GetMeshFromAssets("realgoonieboard")));
			RegisterUnlock(new MPSkateboardSkin("Goonie (Chibi)", "By: Keziah_L", Animator.StringToHash("gooniechibi"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("goonietex"), GetMeshFromAssets("gooniechibi")));
			RegisterUnlock(new MPSkateboardSkin("Thunder Kick", "By: Thunder Kick", Animator.StringToHash("thunderkickdeck"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("thunderkickdeck")));
			RegisterUnlock(new MPSkateboardSkin("Junkyard Dog", "By: Yurok and Keziah_L", Animator.StringToHash("yurokBoard"), unlockedByDefault: true, (Texture)(object)GetTextureFromAssets("yurokBoardTex"), GetMeshFromAssets("yurokBoard")));
			RegisterUnlock(new MPSkateboardSkin("Shadow SA2", "By: Lance", Animator.StringToHash("shadowsa2"), unlockedByDefault: true, GetMaterialFromAssets("ShadowSA2Mat")));
			RegisterUnlock(new MPBuiltInSkin((MoveStyle)3, 6969420));
			RegisterUnlock(new MPBuiltInSkin((MoveStyle)2, 5318008));
			RegisterUnlock(new MPBuiltInSkin((MoveStyle)1, 6767420));
		}

		private Material GetMaterialFromAssets(string name)
		{
			return MPAssets.Instance.Bundle.LoadAsset<Material>(name);
		}

		private Texture2D GetTextureFromAssets(string name)
		{
			return MPAssets.Instance.Bundle.LoadAsset<Texture2D>(name);
		}

		private Mesh GetMeshFromAssets(string name)
		{
			return MPAssets.Instance.Bundle.LoadAsset<GameObject>(name).GetComponentInChildren<MeshFilter>().sharedMesh;
		}

		private void RegisterUnlock(MPUnlockable unlock)
		{
			UnlockByID[unlock.Identifier] = unlock;
		}
	}
	public static class MPUtility
	{
		public static string GetOrCreateSystemGUID()
		{
			string text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "NetworkInformation");
			Directory.CreateDirectory(text);
			string path = Path.Combine(text, "cryptokey.dat");
			string text2 = "";
			if (File.Exists(path))
			{
				try
				{
					text2 = File.ReadAllText(path);
					if (!Utility.IsNullOrWhiteSpace(text2) && Guid.TryParse(text2, out var _))
					{
						return text2;
					}
				}
				catch
				{
				}
			}
			text2 = Guid.NewGuid().ToString();
			File.WriteAllText(path, text2);
			return text2;
		}

		public static string GetHierarchyPath(GameObject go)
		{
			string text = ((Object)go).name;
			Transform val = go.transform;
			while ((Object)(object)val.parent != (Object)null)
			{
				val = val.parent;
				text = ((Object)val).name + "/" + text;
			}
			return text;
		}

		public static int GenerateGameObjectID(GameObject obj)
		{
			return Compression.HashString(GetHierarchyPath(obj) + $"${obj.transform.GetSiblingIndex()}");
		}

		public static string ParseMessageEmojis(string message)
		{
			foreach (KeyValuePair<string, int> sprite in MPAssets.Instance.Emojis.Sprites)
			{
				message = message.Replace(sprite.Key, $"<sprite={sprite.Value}>");
			}
			return message;
		}

		public static string GetTeamName(LobbyState lobbyState, Team team, byte teamId)
		{
			IEnumerable<KeyValuePair<ushort, LobbyPlayer>> enumerable = lobbyState.Players.Where((KeyValuePair<ushort, LobbyPlayer> x) => x.Value.Team == teamId);
			bool flag = false;
			string text = "";
			foreach (KeyValuePair<ushort, LobbyPlayer> item in enumerable)
			{
				string crewName = ClientController.Instance.Players[item.Key].ClientState.CrewName;
				if (!flag)
				{
					flag = true;
					text = crewName;
				}
				else if (crewName != text)
				{
					return "";
				}
			}
			return text;
		}

		public static string GetCrewDisplayName(string name)
		{
			name = TMPFilter.Sanitize(name);
			name = TMPFilter.FilterTags(name, MPSettings.Instance.ChatCriteria);
			name = TMPFilter.CloseAllTags(name);
			if (ProfanityFilter.TMPContainsProfanity(name))
			{
				name = ((!MPSettings.Instance.FilterProfanity) ? (name + "<sprite=37><color=red>[FILTERED]</color>") : "");
			}
			name = name.Trim();
			if (Utility.IsNullOrWhiteSpace(TMPFilter.RemoveAllTags(name)))
			{
				name = "";
			}
			return name;
		}

		public static string GetPlayerDisplayName(string name)
		{
			name = TMPFilter.Sanitize(name);
			name = TMPFilter.FilterTags(name, MPSettings.Instance.ChatCriteria);
			name = TMPFilter.CloseAllTags(name);
			if (ProfanityFilter.TMPContainsProfanity(name))
			{
				name = ((!MPSettings.Instance.FilterProfanity) ? (name + "<sprite=37><color=red>[FILTERED]</color>") : "Punished Slopper");
			}
			name = name.Trim();
			if (Utility.IsNullOrWhiteSpace(TMPFilter.RemoveAllTags(name)))
			{
				name = "Big Slopper";
			}
			return name;
		}

		public static string GetPlayerDisplayNameWithoutTags(ClientState clientState)
		{
			string name = clientState.Name;
			name = TMPFilter.RemoveAllTags(GetPlayerDisplayName(name));
			AuthUser user = clientState.User;
			if (AprilClient.GetAprilEventEnabled())
			{
				name = $"<sprite={AprilClient.GetBadgeForName(clientState.Name)}> {name}";
			}
			if (clientState.ShowBadges)
			{
				int[] badges = user.Badges;
				foreach (int num in badges)
				{
					name = $"<sprite={num}> {name}";
				}
			}
			return name;
		}

		public static string GetPlayerDisplayName(ClientState clientState)
		{
			string name = clientState.Name;
			name = GetPlayerDisplayName(name);
			AuthUser user = clientState.User;
			if (AprilClient.GetAprilEventEnabled())
			{
				name = $"<sprite={AprilClient.GetBadgeForName(clientState.Name)}> {name}";
			}
			if (clientState.ShowBadges)
			{
				int[] badges = user.Badges;
				foreach (int num in badges)
				{
					name = $"<sprite={num}> {name}";
				}
			}
			return name;
		}

		public static void PlaceCurrentPlayer(Vector3 position, Quaternion rotation)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			PlacePlayer(WorldHandler.instance.GetCurrentPlayer(), position, rotation);
		}

		public static void PlacePlayer(Player player, Vector3 position, Quaternion rotation)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			player.CompletelyStop();
			WorldHandler.instance.PlacePlayerAt(player, position, rotation, true);
			player.CompletelyStop();
			player.SetPosAndRotHard(position, rotation);
		}

		public static void PlayerHitboxesToEnemy(Player player)
		{
			Transform[] componentsInChildren = ((Component)player).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Component)val).gameObject.layer == 18)
				{
					((Component)val).gameObject.layer = 20;
				}
			}
		}

		public static Player CreateMultiplayerPlayer(Characters character, int outfit, MPPlayer multiplayerPlayer)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			if ((int)character == -1)
			{
				character = (Characters)3;
			}
			if (outfit < 0 || outfit > 3)
			{
				outfit = 0;
			}
			ClientController instance = ClientController.Instance;
			WorldHandler instance2 = WorldHandler.instance;
			Player component = Object.Instantiate<GameObject>(instance2.playerPrefab, Vector3.zero, Quaternion.identity).GetComponent<Player>();
			component.tf.SetAsFirstSibling();
			component.motor._rigidbody.isKinematic = true;
			component.motor._rigidbody.useGravity = false;
			instance2.RegisterPlayer(component);
			instance2.InitPlayer(component, character, outfit, (PlayerType)3, (MoveStyle)2, (Crew)1);
			instance.MultiplayerPlayerByPlayer[component] = multiplayerPlayer;
			Core.OnCoreUpdatePaused -= new OnCoreUpdateHandler(component.OnCoreUpdatePaused);
			Core.OnCoreUpdateUnPaused -= new OnCoreUpdateUnpausedHandler(component.OnCoreUpdateUnPaused);
			PlayerHitboxesToEnemy(component);
			if (!MPSettings.Instance.PlayerDopplerEnabled)
			{
				AudioSource[] componentsInChildren = ((Component)component).GetComponentsInChildren<AudioSource>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].dopplerLevel = 0f;
				}
			}
			PlayerComponent playerComponent = PlayerComponent.Get(component);
			playerComponent.SkinLoaded = (Action)Delegate.Combine(playerComponent.SkinLoaded, new Action(multiplayerPlayer.OnSkinLoaded));
			return component;
		}

		public static string RemoveCrewTag(string text)
		{
			text = new Regex("\\[[^\\]]*\\]").Replace(text, string.Empty);
			return text;
		}

		public static bool IsMultiplayerPlayer(Player player)
		{
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			return instance.MultiplayerPlayerByPlayer.ContainsKey(player);
		}

		public static MPPlayer GetMuliplayerPlayer(Player player)
		{
			if (!IsMultiplayerPlayer(player))
			{
				return null;
			}
			return ClientController.Instance.MultiplayerPlayerByPlayer[player];
		}

		public static void PlayAnimationOnMultiplayerPlayer(Player player, int newAnim, bool forceOverwrite = false, bool instant = false, float atTime = -1f)
		{
			PlayerPatch.PlayAnimPatchEnabled = false;
			try
			{
				player.PlayAnim(newAnim, forceOverwrite, instant, atTime);
			}
			finally
			{
				PlayerPatch.PlayAnimPatchEnabled = true;
			}
		}

		public static void SetUpPlayerForGameStateUpdate()
		{
			if ((Object)(object)MinecraftPlayer.Instance != (Object)null)
			{
				MinecraftPlayer.Instance.Kill();
			}
			CloseMenusAndSpectator();
			UIManager uIManager = Core.Instance.UIManager;
			if (uIManager.menuNavigationController.IsMenuPartOfMenuStack((IUIMenuController)(object)uIManager.pauseMenu))
			{
				uIManager.pauseMenu.ResumeCurrentGame();
			}
			Core.Instance.UIManager.PopAllMenusInstant();
			GraffitiGame val = Object.FindObjectOfType<GraffitiGame>();
			if ((Object)(object)val != (Object)null)
			{
				val.CancelGame();
			}
			if (WorldHandler.instance.GetCurrentPlayer().IsDead())
			{
				Revive();
			}
			Teleport[] array = Object.FindObjectsOfType<Teleport>();
			foreach (Teleport val2 in array)
			{
				if (val2.teleportRoutine != null)
				{
					((MonoBehaviour)val2).StopAllCoroutines();
					val2.teleportRoutine = null;
				}
			}
			((Component)Core.Instance.UIManager.effects.fullScreenFade).gameObject.SetActive(false);
		}

		public static void CloseMenusAndSpectator()
		{
			SpectatorController instance = SpectatorController.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.EndSpectating();
			}
			PlayerListUI instance2 = PlayerListUI.Instance;
			if ((Object)(object)instance2 != (Object)null)
			{
				instance2.Displaying = false;
			}
			StatsUI instance3 = StatsUI.Instance;
			if ((Object)(object)instance3 != (Object)null && instance3.Displaying)
			{
				instance3.Deactivate();
			}
		}

		public static bool AnyMenusOpen()
		{
			if (PlayerListUI.Instance.Displaying)
			{
				return true;
			}
			if (StatsUI.Instance.Displaying)
			{
				return true;
			}
			return false;
		}

		public static void Revive()
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)MinecraftPlayer.Instance != (Object)null)
			{
				MinecraftPlayer.Instance.Kill();
			}
			DeathSequenceController instance = DeathSequenceController.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.End();
			}
			DieMenu dieMenu = Core.instance.UIManager.dieMenu;
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			currentPlayer.Revive();
			currentPlayer.cam.cam.clearFlags = (CameraClearFlags)1;
			currentPlayer.cam.cam.cullingMask = WorldHandler.GetGameplayCameraCullingMask();
			currentPlayer.CompletelyStop();
			dieMenu.baseModule.UnPauseGame((PauseType)256);
			((MonoBehaviour)dieMenu).StopAllCoroutines();
			((AMenuController)dieMenu).uIManager.PopAllMenusInstant();
			currentPlayer.ui.TurnOn(true);
			StageProgress currentStageProgress = Core.Instance.SaveManager.CurrentSaveSlot.GetCurrentStageProgress();
			PlaceCurrentPlayer(currentStageProgress.respawnPos, Quaternion.Euler(currentStageProgress.respawnRot));
		}

		public static PublicToilet GetCurrentToilet()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			SequenceHandler instance = SequenceHandler.instance;
			if (instance.IsInSequence())
			{
				PlayableDirector sequence = instance.sequence;
				if ((Object)(object)sequence != (Object)null && (int)sequence.state == 1)
				{
					PublicToilet componentInParent = ((Component)sequence).GetComponentInParent<PublicToilet>(true);
					if ((Object)(object)componentInParent != (Object)null)
					{
						return componentInParent;
					}
				}
			}
			return null;
		}

		public static bool IsChristmas()
		{
			return false;
		}

		public static void PingInMap(GameObject go, float duration)
		{
			MapPin val = Mapcontroller.Instance.CreatePin((PinType)2);
			val.AssignGameplayEvent(go);
			val.InitMapPin((PinType)2);
			val.OnPinEnable();
			Object.Destroy((Object)(object)((Component)((Component)val).transform.Find("InViewVisualization")).gameObject.GetComponentInChildren<MeshRenderer>());
			val.SetLocation();
			((Component)val).gameObject.AddComponent<TemporaryMapPin>().Initialize(duration, val);
		}

		public static void MakePlayerDance(Player ply)
		{
			ply.PlayAnim(ply.characterVisual.bounceAnimHash, true, true, -1f);
		}

		public static void BreakAllBreakables()
		{
			BreakableObject[] array = Object.FindObjectsOfType<BreakableObject>(true);
			for (int i = 0; i < array.Length; i++)
			{
				((Component)array[i]).gameObject.SetActive(false);
			}
		}

		public static void ResetProps()
		{
			WorldHandler.instance.SceneObjectsRegister.stageChunks.ForEach(delegate(StageChunk chunk)
			{
				JunkBehaviour junkBehaviour2 = chunk.junkBehaviour;
				junkBehaviour2.kickedJunkIndex = 0;
				junkBehaviour2.nonupdatingJunkIndex = 0;
				Junk[] totalJunk2 = junkBehaviour2.totalJunk;
				foreach (Junk val2 in totalJunk2)
				{
					JunkBehaviour.RestoreSingle(junkBehaviour2, val2);
				}
			});
			JunkStageHandler[] array = Object.FindObjectsOfType<JunkStageHandler>();
			for (int i = 0; i < array.Length; i++)
			{
				JunkBehaviour junkBehaviour = array[i].junkBehaviour;
				junkBehaviour.kickedJunkIndex = 0;
				junkBehaviour.nonupdatingJunkIndex = 0;
				Junk[] totalJunk = junkBehaviour.totalJunk;
				foreach (Junk val in totalJunk)
				{
					JunkBehaviour.RestoreSingle(junkBehaviour, val);
				}
			}
		}
	}
	public class Nameplate : MonoBehaviour
	{
		public TextMeshPro Label;

		public static Nameplate Create()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			GameObject val = new GameObject("Nameplate Container");
			Nameplate nameplate = val.AddComponent<Nameplate>();
			nameplate.Label = val.AddComponent<TextMeshPro>();
			((TMP_Text)nameplate.Label).fontSize = 2f;
			nameplate.Label.sortingOrder = 1;
			((TMP_Text)nameplate.Label).horizontalAlignment = (HorizontalAlignmentOptions)2;
			((TMP_Text)nameplate.Label).verticalAlignment = (VerticalAlignmentOptions)512;
			((TMP_Text)nameplate.Label).spriteAsset = MPAssets.Instance.Sprites;
			return nameplate;
		}

		private void OnWillRenderObject()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.rotation = ((Component)Camera.current).transform.rotation;
		}
	}
	public class NotificationController : MonoBehaviour
	{
		private NotificationUI _notificationUI;

		private UIManager _uiManager;

		public static NotificationController Instance { get; private set; }

		public bool HasNotificationUp => _notificationUI.HasNotificationUp;

		private void Awake()
		{
			Instance = this;
			GameObject gameObject = ((Component)((Component)this).transform.Find("Canvas").Find("Notification")).gameObject;
			_notificationUI = gameObject.AddComponent<NotificationUI>();
			ClientController.PacketReceived = (Action<Packets, Packet>)Delegate.Combine(ClientController.PacketReceived, new Action<Packets, Packet>(OnPacketReceived));
		}

		private void OnDestroy()
		{
			ClientController.PacketReceived = (Action<Packets, Packet>)Delegate.Combine(ClientController.PacketReceived, new Action<Packets, Packet>(OnPacketReceived));
		}

		public void RemoveNotificationForLobby(uint lobby)
		{
			_notificationUI.RemoveNotificationForLobby(lobby);
		}

		public void RemoveAllNotifications()
		{
			_notificationUI.RemoveAllNotifications();
		}

		private void OnPacketReceived(Packets packetId, Packet packet)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			ClientController instance = ClientController.Instance;
			ClientLobbyManager clientLobbyManager = instance.ClientLobbyManager;
			if ((int)packetId == 27)
			{
				ServerLobbyInvite val = (ServerLobbyInvite)packet;
				_ = val.InviterId;
				ushort inviteeId = val.InviteeId;
				uint lobbyId = val.LobbyId;
				if (inviteeId == instance.LocalID && _notificationUI.CanQueueAtThisTime())
				{
					_notificationUI.QueueInviteNotification(clientLobbyManager.Lobbies[lobbyId]);
				}
			}
		}

		public static void Create()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			GameObject obj = Object.Instantiate<GameObject>(MPAssets.Instance.Bundle.LoadAsset<GameObject>("Notification UI"));
			obj.transform.SetParent(((Component)Core.Instance.UIManager).transform, false);
			obj.AddComponent<NotificationController>();
		}
	}
	public class NotificationUI : MonoBehaviour
	{
		private enum States
		{
			Closed,
			Opening,
			Open,
			Closing
		}

		private class Notification
		{
			public ClientState HostPlayer;

			public string LobbyName = "";

			public int LobbyPlayers;

			public uint Lobby;

			public Notification(ClientState hostPlayer, string lobbyName, int lobbyPlayers, uint associatedLobby = 0u)
			{
				HostPlayer = hostPlayer;
				LobbyName = lobbyName;
				LobbyPlayers = lobbyPlayers;
				Lobby = associatedLobby;
			}
		}

		private float _speed = 750f;

		private float _stayTime = 4f;

		private TextMeshProUGUI _gamemodeLabel;

		private TextMeshProUGUI _hostLabel;

		private TextMeshProUGUI _playerCountLabel;

		private TextMeshProUGUI _glyph;

		private float _defaultX;

		private float _xSize;

		private Queue<Notification> _notificationQueue = new Queue<Notification>();

		private States _state;

		private float _stateTimer;

		public bool Active = true;

		public bool HasNotificationUp => _state != States.Closed;

		private void Awake()
		{
			//IL_008d: 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)
			_gamemodeLabel = ((Component)((Component)this).transform.Find("Gamemode")).GetComponent<TextMeshProUGUI>();
			_hostLabel = ((Component)((Component)this).transform.Find("Host")).GetComponent<TextMeshProUGUI>();
			((TMP_Text)_hostLabel).spriteAsset = MPAssets.Instance.Sprites;
			_playerCountLabel = ((Component)((Component)this).transform.Find("People Count")).GetComponent<TextMeshProUGUI>();
			_glyph = ((Component)((Component)this).transform.Find("Glyph")).GetComponent<TextMeshProUGUI>();
			_xSize = TransformExtentions.RectTransform(((Component)this).transform).sizeDelta.x;
			_defaultX = ((Component)this).transform.localPosition.x;
			UIUtility.MakeGlyph(_glyph, 21);
			SnapClosed();
			Active = ((Component)this).gameObject.activeSelf;
		}

		private void OnDisable()
		{
			Active = false;
			SnapClosed();
		}

		private void OnEnable()
		{
			Active = true;
			SnapClosed();
		}

		private void Update()
		{
			_stateTimer += Time.deltaTime;
			UpdateAnimation();
			if (_state == States.Open && _stateTimer >= _stayTime)
			{
				SetState(States.Closing);
			}
			if (_state == States.Closed && CanOpenAtThisTime())
			{
				OpenNextNotificationIfPossible();
			}
			if (!CanOpenAtThisTime())
			{
				SnapClosed();
			}
		}

		public void QueueInviteNotification(Lobby lobby)
		{
			ClientController instance = ClientController.Instance;
			Notification item = new Notification(instance.Players[lobby.LobbyState.HostId].ClientState, instance.ClientLobbyManager.GetLobbyName(lobby.LobbyState.Id), lobby.LobbyState.Players.Count, lobby.LobbyState.Id);
			_notificationQueue.Enqueue(item);
			Core.Instance.AudioManager.PlaySfxUI((SfxCollectionID)14, (AudioClipID)307, 0f);
		}

		public void RemoveNotificationForLobby(uint lobby)
		{
			_notificationQueue = new Queue<Notification>(_notificationQueue.Where((Notification x) => x.Lobby != lobby));
		}

		public void RemoveAllNotifications()
		{
			_notificationQueue.Clear();
		}

		public bool CanQueueAtThisTime()
		{
			if (!MPSettings.Instance.ShowNotifications)
			{
				return false;
			}
			return true;
		}

		public bool CanOpenAtThisTime()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			UIManager uIManager = Core.Instance.UIManager;
			if (!CanQueueAtThisTime())
			{
				return false;
			}
			if ((int)WorldHandler.instance.GetCurrentPlayer().phone.state != 0)
			{
				return false;
			}
			if (!((Component)uIManager.gameplay.gameplayScreen).gameObject.activeSelf)
			{
				return false;
			}
			Lobby currentLobby = instance.ClientLobbyManager.CurrentLobby;
			if (currentLobby != null && currentLobby.InGame)
			{
				return false;
			}
			return true;
		}

		private void OpenNextNotificationIfPossible()
		{
			if (_notificationQueue.Count != 0)
			{
				Notification notification = _notificationQueue.Dequeue();
				SetNotification(notification);
				SetState(States.Opening);
			}
		}

		private void SetNotification(Notification notification)
		{
			((TMP_Text)_gamemodeLabel).text = notification.LobbyName;
			if (notification.HostPlayer != null)
			{
				((TMP_Text)_hostLabel).text = MPUtility.GetPlayerDisplayName(notification.HostPlayer);
			}
			((TMP_Text)_playerCountLabel).text = notification.LobbyPlayers.ToString();
		}

		private void UpdateAnimation()
		{
			//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_0055: 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_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_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)
			switch (_state)
			{
			case States.Closed:
				SnapClosed();
				break;
			case States.Open:
				SnapOpen();
				break;
			case States.Opening:
			{
				Vector3 localPosition2 = ((Component)this).transform.localPosition;
				localPosition2.x += _speed * Time.deltaTime;
				((Component)this).transform.localPosition = localPosition2;
				if (localPosition2.x >= _defaultX)
				{
					SetState(States.Open);
				}
				break;
			}
			case States.Closing:
			{
				Vector3 localPosition = ((Component)this).transform.localPosition;
				localPosition.x -= _speed * Time.deltaTime;
				((Component)this).transform.localPosition = localPosition;
				if (localPosition.x <= _defaultX - _xSize)
				{
					SetState(States.Closed);
				}
				break;
			}
			}
		}

		private void SetState(States state)
		{
			if (state != _state)
			{
				_stateTimer = 0f;
			}
			_state = state;
		}

		private void SnapOpen()
		{
			//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_0026: Unknown result type (might be due to invalid IL or missing references)
			SetState(States.Open);
			Vector3 localPosition = ((Component)this).transform.localPosition;
			localPosition.x = _defaultX;
			((Component)this).transform.localPosition = localPosition;
		}

		private void SnapClosed()
		{
			//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_002d: Unknown result type (might be due to invalid IL or missing references)
			SetState(States.Closed);
			Vector3 localPosition = ((Component)this).transform.localPosition;
			localPosition.x = _defaultX - _xSize;
			((Component)this).transform.localPosition = localPosition;
		}
	}
	public class PlayerComponent : MonoBehaviour
	{
		public bool LOD;

		private const float HelloCooldown = 2f;

		private const float AFKEnterSpeed = 4f;

		private const float AFKExitSpeed = 8f;

		public SpecialSkins SpecialSkin = (SpecialSkins)(-1);

		public int SpecialSkinVariant = -1;

		public SkinnedMeshRenderer MainRenderer;

		public bool AFK;

		private ParticleSystem _afkParticles;

		private Player _player;

		private float _afkWeight;

		private float _afkTimer;

		private bool _afkForced;

		private float _helloTimer;

		public Material SkateboardMaterial;

		public Material InlineMaterial;

		public Material BMXMaterial;

		public Material BMXSpokesMaterial;

		public MPMoveStyleSkin MovestyleSkin;

		public bool Chibi;

		public StreamedCharacterInstance StreamedCharacter;

		public Action SkinLoaded;

		public bool ChallengeIndicatorVisible;

		private GameObject _challengeIndicator;

		public GameObject DisguiseGameObject;

		public int DisguiseID;

		public bool LocalIgnore;

		public PseudoDieAbility PseudoDieAbility;

		private GameObject _customInlines;

		private GameObject _customSkateboard;

		private GameObject _customBmx;

		public CharacterHandle StreamedCharacterHandle;

		public int StreamedOutfit;

		private static int MainTexId = Shader.PropertyToID("_MainTex");

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

		public bool Local => (Object)(object)_player == (Object)(object)WorldHandler.instance.GetCurrentPlayer();

		public Player Player => _player;

		public bool HasPropDisguise => (Object)(object)DisguiseGameObject != (Object)null;

		public bool HasCustomInlines => (Object)(object)_customInlines != (Object)null;

		public bool HasCustomSkateboard => (Object)(object)_customSkateboard != (Object)null;

		public bool HasCustomBmx => (Object)(object)_customBmx != (Object)null;

		public void CacheNewSkin()
		{
			_customInlines = null;
			Transform val = TransformExtentions.FindRecursive(((Component)_player.characterVisual).transform, "builtin_inlines");
			if ((Object)(object)val != (Object)null)
			{
				_customInlines = ((Component)val).gameObject;
			}
			Transform val2 = TransformExtentions.FindRecursive(((Component)_player.characterVisual).transform, "builtin_skate");
			if ((Object)(object)val2 != (Object)null)
			{
				_customSkateboard = ((Component)val2).gameObject;
			}
			Transform val3 = TransformExtentions.FindRecursive(((Component)_player.characterVisual).transform, "builtin_bmx");
			if ((Object)(object)val3 != (Object)null)
			{
				_customBmx = ((Component)val3).gameObject;
			}
			if (MovestyleSkin != null)
			{
				MovestyleSkin.ApplyToPlayer(_player);
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)SkateboardMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)SkateboardMaterial);
			}
			if ((Object)(object)BMXMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)BMXMaterial);
			}
			if ((Object)(object)InlineMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)InlineMaterial);
			}
			if ((Object)(object)BMXSpokesMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)BMXSpokesMaterial);
			}
			UnloadStreamedCharacter();
		}

		public void RemovePropDisguise()
		{
			if (HasPropDisguise)
			{
				Object.Destroy((Object)(object)DisguiseGameObject);
				DisguiseGameObject = null;
				((Component)_player.visualTf).gameObject.SetActive(true);
			}
		}

		private void OnEnable()
		{
			if (HasPropDisguise && PropDisguiseController.Instance.PropByIndex.TryGetValue(DisguiseID, out var value))
			{
				StreetLife component = value.GetComponent<StreetLife>();
				if (!((Object)(object)component == (Object)null))
				{
					Animator component2 = DisguiseGameObject.GetComponent<Animator>();
					int num = Animator.StringToHash(((object)(IdleAnimation)(ref component.idleAnimation)).ToString());
					component2.Play(num, 0);
				}
			}
		}

		private void AutoAdjustProp()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: 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_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			if (!HasPropDisguise)
			{
				return;
			}
			Renderer componentInChildren = DisguiseGameObject.GetComponentInChildren<Renderer>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return;
			}
			Bounds localBounds = componentInChildren.localBounds;
			Vector3[] array = (Vector3[])(object)new Vector3[8]
			{
				new Vector3(((Bounds)(ref localBounds)).min.x, ((Bounds)(ref localBounds)).min.y, ((Bounds)(ref localBounds)).min.z),
				new Vector3(((Bounds)(ref localBounds)).min.x, ((Bounds)(ref localBounds)).min.y, ((Bounds)(ref localBounds)).max.z),
				new Vector3(((Bounds)(ref localBounds)).min.x, ((Bounds)(ref localBounds)).max.y, ((Bounds)(ref localBounds)).max.z),
				new Vector3(((Bounds)(ref localBounds)).min.x, ((Bounds)(ref localBounds)).max.y, ((Bounds)(ref localBounds)).min.z),
				new Vector3(((Bounds)(ref localBounds)).max.x, ((Bounds)(ref localBounds)).max.y, ((Bounds)(ref localBounds)).max.z),
				new Vector3(((Bounds)(ref localBounds)).max.x, ((Bounds)(ref localBounds)).max.y, ((Bounds)(ref localBounds)).min.z),
				new Vector3(((Bounds)(ref localBounds)).max.x, ((Bounds)(ref localBounds)).min.y, ((Bounds)(ref localBounds)).min.z),
				new Vector3(((Bounds)(ref localBounds)).max.x, ((Bounds)(ref localBounds)).min.y, ((Bounds)(ref localBounds)).max.z)
			};
			Vector3 val = Vector3.zero;
			float num = float.PositiveInfinity;
			for (int i = 0; i < array.Length; i++)
			{
				Vector3 val2 = ((Component)_player).transform.InverseTransformPoint(((Component)componentInChildren).transform.TransformPoint(array[i]));
				val += val2;
				if (val2.y < num)
				{
					num = val2.y;
				}
			}
			val /= (float)array.Length;
			val.y = num;
			DisguiseGameObject.transform.localPosition = -val;
		}

		public void ApplyPropDisguise(int disguiseId)
		{
			//IL_00fc: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			if (!PropDisguiseController.Instance.PropByIndex.TryGetValue(disguiseId, out var value))
			{
				return;
			}
			DisguiseID = disguiseId;
			if (HasPropDisguise)
			{
				Object.Destroy((Object)(object)DisguiseGameObject);
			}
			((Component)_player.visualTf).gameObject.SetActive(false);
			GameObject val = Object.Instantiate<GameObject>(value);
			val.gameObject.SetActive(true);
			DisguiseGameObject = val;
			bool flag = false;
			Junk component = val.GetComponent<Junk>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
				flag = true;
			}
			Rigidbody component2 = val.GetComponent<Rigidbody>();
			if ((Object)(object)component2 != (Object)null)
			{
				Object.Destroy((Object)(object)component2);
			}
			StreetLife component3 = val.GetComponent<StreetLife>();
			if ((Object)(object)component3 != (Object)null)
			{
				Animator component4 = val.GetComponent<Animator>();
				if ((Object)(object)component4 != (Object)null)
				{
					int num = Animator.StringToHash(((object)(IdleAnimation)(ref component3.idleAnimation)).ToString());
					component4.Play(num, 0);
				}
				Object.Destroy((Object)(object)component3);
			}
			val.transform.SetParent(((Component)_player).transform);
			val.transform.SetLocalPositionAndRotation(Vector2.op_Implicit(Vector2.zero), Quaternion.identity);
			if (flag)
			{
				val.transform.rotation = value.transform.rotation;
			}
			val.transform.localScale = value.transform.localScale;
			if (Local)
			{
				if ((Object)(object)component3 == (Object)null)
				{
					AutoAdjustProp();
				}
				val.gameObject.layer = 15;
				Collider[] components = val.GetComponents<Collider>();
				for (int i = 0; i < components.Length; i++)
				{
					Object.Destroy((Object)(object)components[i]);
				}
			}
		}

		public void ApplyMoveStyleMaterial(Material[] customMaterials)
		{
			if ((Object)(object)SkateboardMaterial == (Object)null)
			{
				throw CreateException("SkateboardMaterial");
			}
			if ((Object)(object)InlineMaterial == (Object)null)
			{
				throw CreateException("InlineMaterial");
			}
			if ((Object)(object)BMXMaterial == (Object)null)
			{
				throw CreateException("BMXMaterial");
			}
			if ((Object)(object)BMXSpokesMaterial == (Object)null)
			{
				throw CreateException("BMXSpokesMaterial");
			}
			PlayerMoveStyleProps moveStyleProps = _player.characterVisual.moveStyleProps;
			List<MeshRenderer> list = moveStyleProps.bmxPedalR.GetComponentsInChildren<MeshRenderer>().ToList();
			list.AddRange(moveStyleProps.bmxPedalL.GetComponentsInChildren<MeshRenderer>());
			list.AddRange(moveStyleProps.bmxFrame.GetComponentsInChildren<MeshRenderer>());
			list.AddRange(moveStyleProps.bmxGear.GetComponentsInChildren<MeshRenderer>());
			list.AddRange(moveStyleProps.bmxHandlebars.GetComponentsInChildren<MeshRenderer>());
			list.AddRange(moveStyleProps.bmxWheelF.GetComponentsInChildren<MeshRenderer>());
			list.AddRange(moveStyleProps.bmxWheelR.GetComponentsInChildren<MeshRenderer>());
			foreach (MeshRenderer item in list)
			{
				((Renderer)item).sharedMaterials = customMaterials;
			}
			List<MeshRenderer> list2 = moveStyleProps.skateL.GetComponentsInChildren<MeshRenderer>().ToList();
			list2.AddRange(moveStyleProps.skateR.GetComponentsInChildren<MeshRenderer>());
			foreach (MeshRenderer item2 in list2)
			{
				((Renderer)item2).sharedMaterials = customMaterials;
			}
			foreach (MeshRenderer item3 in moveStyleProps.skateboard.GetComponentsInChildren<MeshRenderer>().ToList())
			{
				((Renderer)item3).sharedMaterials = customMaterials;
			}
			static Exception CreateException(string variableName)
			{
				return new Exception("Tried to apply a custom MoveStyle material before caching " + variableName + " in PlayerComponent. Call ApplyMoveStyleSkin first!");
			}
		}

		public void ApplyMoveStyleSkin(int skinIndex)
		{
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Expected O, but got Unknown
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Expected O, but got Unknown
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Invalid comparison between Unknown and I4
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_0448: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			MovestyleSkin = null;
			PlayerMoveStyleProps moveStyleProps = _player.characterVisual.moveStyleProps;
			Mesh sharedMesh = _player.MoveStylePropsPrefabs.bmxFrame.GetComponent<MeshFilter>().sharedMesh;
			Mesh sharedMesh2 = _player.MoveStylePropsPrefabs.bmxGear.GetComponent<MeshFilter>().sharedMesh;
			Mesh sharedMesh3 = _player.MoveStylePropsPrefabs.bmxHandlebars.GetComponent<MeshFilter>().sharedMesh;
			Mesh sharedMesh4 = _player.MoveStylePropsPrefabs.bmxPedalL.GetComponent<MeshFilter>().sharedMesh;
			Mesh sharedMesh5 = _player.MoveStylePropsPrefabs.bmxPedalR.GetComponent<MeshFilter>().sharedMesh;
			Mesh sharedMesh6 = _player.MoveStylePropsPrefabs.bmxWheelF.GetComponent<MeshFilter>().sharedMesh;
			Mesh sharedMesh7 = _player.MoveStylePropsPrefabs.bmxWheelR.GetComponent<MeshFilter>().sharedMesh;
			Mesh sharedMesh8 = _player.MoveStylePropsPrefabs.skateboard.GetComponent<MeshFilter>().sharedMesh;
			Mesh sharedMesh9 = _player.MoveStylePropsPrefabs.skateL.GetComponent<MeshFilter>().sharedMesh;
			Mesh sharedMesh10 = _player.MoveStylePropsPrefabs.skateR.GetComponent<MeshFilter>().sharedMesh;
			moveStyleProps.bmxFrame.GetComponent<MeshFilter>().sharedMesh = sharedMesh;
			moveStyleProps.bmxGear.GetComponent<MeshFilter>().sharedMesh = sharedMesh2;
			moveStyleProps.bmxHandlebars.GetComponent<MeshFilter>().sharedMesh = sharedMesh3;
			moveStyleProps.bmxPedalL.GetComponent<MeshFilter>().sharedMesh = sharedMesh4;
			moveStyleProps.bmxPedalR.GetComponent<MeshFilter>().sharedMesh = sharedMesh5;
			moveStyleProps.bmxWheelF.GetComponent<MeshFilter>().sharedMesh = sharedMesh6;
			moveStyleProps.bmxWheelR.GetComponent<MeshFilter>().sharedMesh = sharedMesh7;
			moveStyleProps.skateboard.GetComponent<MeshFilter>().sharedMesh = sharedMesh8;
			moveStyleProps.skateL.GetComponent<MeshFilter>().sharedMesh = sharedMesh9;
			moveStyleProps.skateR.GetComponent<MeshFilter>().sharedMesh = sharedMesh10;
			if ((Object)(object)SkateboardMaterial == (Object)null)
			{
				SkateboardMaterial = new Material(((Renderer)moveStyleProps.skateboard.GetComponentInChildren<MeshRenderer>()).sharedMaterial);
			}
			if ((Object)(object)InlineMaterial == (Object)null)
			{
				InlineMaterial = new Material(((Renderer)moveStyleProps.skateL.GetComponentInChildren<MeshRenderer>()).sharedMaterial);
			}
			if ((Object)(object)BMXMaterial == (Object)null)
			{
				BMXMaterial = new Material(((Renderer)moveStyleProps.bmxFrame.GetComponentInChildren<MeshRenderer>()).sharedMaterial);
			}
			if ((Object)(object)BMXSpokesMaterial == (Object)null)
			{
				BMXSpokesMaterial = new Material(((Renderer)moveStyleProps.bmxWheelF.GetComponentInChildren<MeshRenderer>()).sharedMaterials[1]);
			}
			List<MeshRenderer> list = moveStyleProps.bmxPedalR.GetComponentsInChildren<MeshRenderer>().ToList();
			list.AddRange(moveStyleProps.bmxPedalL.GetComponentsInChildren<MeshRenderer>());
			list.AddRange(moveStyleProps.bmxFrame.GetComponentsInChildren<MeshRenderer>());
			list.AddRange(moveStyleProps.bmxGear.GetComponentsInChildren<MeshRenderer>());
			list.AddRange(moveStyleProps.bmxHandlebars.GetComponentsInChildren<MeshRenderer>());
			list.AddRange(moveStyleProps.bmxWheelF.GetComponentsInChildren<MeshRenderer>());
			list.AddRange(moveStyleProps.bmxWheelR.GetComponentsInChildren<MeshRenderer>());
			foreach (MeshRenderer item in list)
			{
				((Renderer)item).sharedMaterials = (Material[])(object)new Material[2] { BMXMaterial, BMXSpokesMaterial };
			}
			List<MeshRenderer> list2 = moveStyleProps.skateL.GetComponentsInChildren<MeshRenderer>().ToList();
			list2.AddRange(moveStyleProps.skateR.GetComponentsInChildren<MeshRenderer>());
			foreach (MeshRenderer item2 in list2)
			{
				((Renderer)item2).sharedMaterials = (Material[])(object)new Material[1] { InlineMaterial };
			}
			foreach (MeshRenderer item3 in moveStyleProps.skateboard.GetComponentsInChildren<MeshRenderer>().ToList())
			{
				((Renderer)item3).sharedMaterials = (Material[])(object)new Material[1] { SkateboardMaterial };
			}
			for (MoveStyle val = (MoveStyle)1; (int)val <= 3; val = (MoveStyle)(val + 1))
			{
				Texture moveStyleSkinTexture = _player.CharacterConstructor.GetMoveStyleSkinTexture(val, skinIndex);
				if ((Object)(object)moveStyleSkinTexture == (Object)null)
				{
					continue;
				}
				Material[] moveStyleMaterials = MoveStyleLoader.GetMoveStyleMaterials(_player, val);
				if (moveStyleMaterials != null)
				{
					Material[] array = moveStyleMaterials;
					for (int i = 0; i < array.Length; i++)
					{
						array[i].mainTexture = moveStyleSkinTexture;
					}
				}
			}
		}

		public bool CanSayHello()
		{
			if (_helloTimer > 0f)
			{
				return false;
			}
			if (_player.IsBusyWithSequence())
			{
				return false;
			}
			if (_player.IsDead())
			{
				return false;
			}
			return true;
		}

		public void DoSayHello()
		{
			MPSaveData.Instance.Stats.TimesSaidHello++;
			Core.Instance.SaveManager.SaveCurrentSaveSlot();
			try
			{
				_player.PlayVoice((AudioClipID)486, (VoicePriority)3, true);
			}
			catch (Exception)
			{
			}
		}

		private void Awake()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			_player = ((Component)this).GetComponent<Player>();
			GameObject val = MPAssets.Instance.Bundle.LoadAsset<GameObject>("AFK Particles");
			GameObject val2 = MPAssets.Instance.Bundle.LoadAsset<GameObject>("Challenge Indicator");
			_challengeIndicator = Object.Instantiate<GameObject>(val2);
			_challengeIndicator.transform.SetParent(((Component)this).transform);
			_challengeIndicator.transform.SetLocalPositionAndRotation(Vector3.up * 2.5f, Quaternion.identity);
			_challengeIndicator.SetActive(false);
			_afkParticles = Object.Instantiate<GameObject>(val).GetComponent<ParticleSystem>();
			((Component)_afkParticles).transform.SetParent(((Component)this).transform);
		}

		public void InitAbilities()
		{
			PseudoDieAbility = new PseudoDieAbility(_player);
		}

		public void StopAFK()
		{
			_afkTimer = 0f;
			AFK = false;
			_afkForced = false;
		}

		public void ForceAFK()
		{
			if (!AFK)
			{
				MPSaveData.Instance.Stats.TimesFallenAsleep++;
				Core.Instance.SaveManager.SaveCurrentSaveSlot();
			}
			_afkTimer = 300f;
			AFK = true;
			_afkForced = true;
		}

		public void UpdateChibi()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			if (Chibi)
			{
				CharacterVisual characterVisual = _player.characterVisual;
				((Component)characterVisual).transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
				characterVisual.head.localScale = new Vector3(2f, 2f, 2f);
				characterVisual.handR.localScale = new Vector3(1.5f, 1.5f, 1.5f);
				characterVisual.handL.localScale = new Vector3(1.5f, 1.5f, 1.5f);
				characterVisual.footR.localScale = new Vector3(1.25f, 1.25f, 1.25f);
				characterVisual.footL.localScale = new Vector3(1.25f, 1.25f, 1.25f);
				_player.playerGameplayVoicesAudioSource.pitch = 1.5f;
			}
			else
			{
				_player.playerGameplayVoicesAudioSource.pitch = 1f;
			}
		}

		private void LateUpdate()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Invalid comparison between Unknown and I4
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Invalid comparison between Unknown and I4
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_050c: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0531: Unknown result type (might be due to invalid IL or missing references)
			//IL_0547: Unknown result type (might be due to invalid IL or missing references)
			//IL_0557: Unknown result type (might be due to invalid IL or missing references)
			//IL_0561: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0571: Unknown result type (might be due to invalid IL or missing references)
			//IL_0576: Unknown result type (might be due to invalid IL or missing references)
			if (MovestyleSkin != null && (int)MovestyleSkin.MoveStyle == 3 && MovestyleSkin is MPBuiltInSkin && (Object)(object)_customInlines != (Object)null)
			{
				_customInlines.SetActive(_player.characterVisual.moveStyleProps.skateL.activeInHierarchy);
			}
			else if ((Object)(object)_customInlines != (Object)null)
			{
				_customInlines.SetActive(false);
			}
			if (MovestyleSkin != null && (int)MovestyleSkin.MoveStyle == 2 && MovestyleSkin is MPBuiltInSkin && (Object)(object)_customSkateboard != (Object)null)
			{
				_customSkateboard.SetActive(_player.characterVisual.moveStyleProps.skateboard.activeInHierarchy);
			}
			else if ((Object)(object)_customSkateboard != (Object)null)
			{
				_customSkateboard.SetActive(false);
			}
			if (MovestyleSkin != null && (int)MovestyleSkin.MoveStyle == 1 && MovestyleSkin is MPBuiltInSkin && (Object)(object)_customBmx != (Object)null)
			{
				_customBmx.SetActive(_player.characterVisual.moveStyleProps.bmxFrame.activeInHierarchy);
			}
			else if ((Object)(object)_customBmx != (Object)null)
			{
				_customBmx.SetActive(false);
			}
			if ((Object)(object)ClientController.Instance == (Object)null)
			{
				return;
			}
			UpdateChibi();
			MPSettings instance = MPSettings.Instance;
			if (!Local && ChallengeIndicatorVisible && ((Component)_player.characterVisual).gameObject.activeSelf)
			{
				if (!_challengeIndicator.gameObject.activeSelf)
				{
					_challengeIndicator.SetActive(true);
				}
				_challengeIndicator.transform.Rotate(Vector3.up * 150f * Core.dt, (Space)1);
				Vector3 localPosition = Vector3.up * 2.5f + Mathf.Sin(Time.realtimeSinceStartup * 5f) * Vector3.up * 0.1f;
				_challengeIndicator.transform.localPosition = localPosition;
			}
			else if (_challengeIndicator.gameObject.activeSelf)
			{
				_challengeIndicator.SetActive(false);
			}
			if (Local)
			{
				_helloTimer -= Core.dt;
				if (_helloTimer <= 0f)
				{
					_helloTimer = 0f;
				}
				GameInput gameInput = Core.Instance.GameInput;
				if (gameInput.GetAllCurrentEnabledControllerMapCategoryIDs(0).controllerMapCategoryIDs.Contains(0) && Input.GetKeyDown(MPSettings.Instance.TalkKey) && CanSayHello())
				{
					DoSayHello();
					_helloTimer = 2f;
				}
				if (!_afkForced)
				{
					float[] array = new float[4]
					{
						gameInput.GetAxis(13, 0),
						gameInput.GetAxis(14, 0),
						gameInput.GetAxis(8, 0),
						gameInput.GetAxis(18, 0)
					};
					for (int i = 0; i < array.Length; i++)
					{
						if (array[i] != 0f)
						{
							StopAFK();
						}
					}
					if (gameInput.GetAnyButtonNew(0))
					{
						StopAFK();
					}
				}
				Lobby currentLobby = ClientController.Instance.ClientLobbyManager.CurrentLobby;
				if (currentLobby != null && currentLobby.InGame)
				{
					if (!_afkForced)
					{
						StopAFK();
					}
				}
				else
				{
					_afkTimer += Core.dt;
					if (_afkTimer >= 300f)
					{
						if (!AFK)
						{
							MPSaveData.Instance.Stats.TimesFallenAsleep++;
							Core.Instance.SaveManager.SaveCurrentSaveSlot();
						}
						AFK = true;
						_afkTimer = 300f;
					}
					else
					{
						AFK = false;
						_afkForced = false;
					}
				}
				if (AFK)
				{
					MPSaveData.Instance.Stats.TimeSpentAsleep += Core.dt;
				}
			}
			if (instance.ShowAFKEffects)
			{
				if (AFK)
				{
					_afkWeight += 4f * Core.dt;
					if (_afkWeight >= 1f)
					{
						_afkWeight = 1f;
					}
				}
				else
				{
					_afkWeight -= 8f * Core.dt;
					if (_afkWeight <= 0f)
					{
						_afkWeight = 0f;
					}
				}
			}
			else
			{
				_afkWeight = 0f;
			}
			CharacterVisual characterVisual = _player.characterVisual;
			if (_afkWeight >= 1f)
			{
				EmissionModule emission = _afkParticles.emission;
				((EmissionModule)(ref emission)).enabled = true;
				if ((Object)(object)characterVisual != (Object)null && characterVisual.canBlink)
				{
					characterVisual.mainRenderer.SetBlendShapeWeight(0, 100f);
				}
			}
			else
			{
				EmissionModule emission2 = _afkParticles.emission;
				((EmissionModule)(ref emission2)).enabled = false;
			}
			if ((Object)(object)characterVisual != (Object)null)
			{
				((Component)_afkParticles).transform.position = ((Component)characterVisual.head).transform.position;
				((Component)_afkParticles).transform.rotation = Quaternion.LookRotation(((Component)_player).transform.forward);
				Transform transform = ((Component)characterVisual.head).transform;
				transform.rotation *= Quaternion.Euler(((Component)characterVisual.head).transform.right * -45f * _afkWeight);
			}
		}

		public static PlayerComponent Get(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			return ((Component)player).GetComponent<PlayerComponent>();
		}

		public static PlayerComponent GetLocal()
		{
			return ClientController.Instance.LocalPlayerComponent;
		}

		public bool SetStreamedCharacter(Guid guid, int outfit)
		{
			if (StreamedCharacterHandle != null)
			{
				StreamedCharacterHandle.Release();
			}
			StreamedCharacterHandle = CrewBoomStreamer.RequestCharacter(guid, MPSettings.Instance.LoadCharactersAsync);
			StreamedOutfit = outfit;
			if (StreamedCharacterHandle == null)
			{
				return false;
			}
			if (StreamedCharacterHandle.Finished)
			{
				OnSkinLoadFinished();
			}
			else
			{
				CharacterHandle streamedCharacterHandle = StreamedCharacterHandle;
				streamedCharacterHandle.OnLoadFinished = (Action)Delegate.Combine(streamedCharacterHandle.OnLoadFinished, new Action(OnSkinLoadFinished));
			}
			return true;
		}

		private void UnloadShownStreamedCharacter()
		{
			if (StreamedCharacter != null)
			{
				StreamedCharacter.Handle.Release();
				StreamedCharacter = null;
			}
		}

		public void UnloadStreamedCharacter()
		{
			if (StreamedCharacterHandle != null)
			{
				CharacterHandle streamedCharacterHandle = StreamedCharacterHandle;
				streamedCharacterHandle.OnLoadFinished = (Action)Delegate.Remove(streamedCharacterHandle.OnLoadFinished, new Action(OnSkinLoadFinished));
				StreamedCharacterHandle.Release();
				StreamedCharacterHandle = null;
			}
			if (StreamedCharacter != null)
			{
				UnloadShownStreamedCharacter();
				StreamedCharacter = null;
			}
		}

		public void ApplyStreamedCharacter()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: 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_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			_player.character = (Characters)3;
			if ((Object)(object)_player.visualTf != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_player.visualTf).gameObject);
			}
			CharacterVisual val = StreamedCharacter.Handle.ConstructVisual();
			val.Init((Characters)(-1), _player.animatorController, true, _player.motor.groundDetection.groundLimit);
			_player.characterVisual = val;
			_player.characterMesh = _player.characterVisual.mainRenderer.sharedMesh;
			((Component)_player.characterVisual).transform.SetParent(((Component)_player).transform.GetChild(0), false);
			((Component)_player.characterVisual).transform.localPosition = Vector3.zero;
			((Component)_player.characterVisual).transform.rotation = Quaternion.LookRotation(((Component)_player).transform.forward);
			((Component)_player.characterVisual.anim).gameObject.AddComponent<AnimationEventRelay>().Init();
			_player.visualTf = ((Component)_player.characterVisual).transform;
			_player.headTf = TransformExtentions.FindRecursive(_player.visualTf, "head");
			_player.phoneDirBone = TransformExtentions.FindRecursive(_player.visualTf, "phoneDirection");
			_player.heightToHead = (_player.headTf.position - _player.visualTf.position).y;
			_player.anim = _player.characterVisual.anim;
			if (_player.curAnim != 0)
			{
				int curAnim = _player.curAnim;
				_player.curAnim = 0;
				_player.PlayAnim(curAnim, false, false, -1f);
			}
			_player.characterVisual.InitVFX(_player.VFXPrefabs);
			_player.characterVisual.InitMoveStyleProps(_player.MoveStylePropsPrefabs);
			_player.characterConstructor.SetMoveStyleSkinsForCharacter(_player, _player.character);
			if (_player.characterVisual.hasEffects)
			{
				_player.boostpackTrail = _player.characterVisual.VFX.boostpackTrail.GetComponent<TrailRenderer>();
				_player.boostpackTrailDefaultWidth = _player.boostpackTrail.startWidth;
				_player.boostpackTrailDefaultTime = _player.boostpackTrail.time;
				_player.spraypaintParticles = _player.characterVisual.VFX.spraypaint.GetComponent<ParticleSystem>();
				_player.characterVisual.VFX.spraypaint.transform.localScale = Vector3.one * 0.5f;
				_player.SetDustEmission(0);
				_player.ringParticles = _player.characterVisual.VFX.ring.GetComponent<ParticleSystem>();
				_player.SetRingEmission(0);
			}
			bool usingEquippedMovestyle = _player.usingEquippedMovestyle;
			_player.SetCurrentMoveStyleEquipped(_player.moveStyleEquipped, true, true);
			_player.InitVisual();
			if (!usingEquippedMovestyle)
			{
				_player.SetMoveStyle((MoveStyle)0, true, true, (GameObject)null);
			}
			if (!_player.isAI)
			{
				MPSaveData.MPCharacterData characterData = MPSaveData.Instance.GetCharacterData(_player.character);
				if (characterData.MPMoveStyleSkin != -1)
				{
					MPUnlockManager instance = MPUnlockManager.Instance;
					if (instance.UnlockByID.ContainsKey(characterData.MPMoveStyleSkin) && instance.UnlockByID[characterData.MPMoveStyleSkin] is MPMoveStyleSkin mPMoveStyleSkin)
					{
						mPMoveStyleSkin.ApplyToPlayer(_player);
					}
				}
			}
			_player.usingEquippedMovestyle = false;
			MainRenderer = null;
			SpecialSkinVariant = -1;
			SpecialSkin = (SpecialSkins)(-1);
			UpdateSkateOffsets();
			StreamedCharacter.SetVisual(val);
			StreamedCharacter.ApplyOutfit(StreamedCharacter.Outfit);
		}

		public void UpdateSkateOffsets()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			Transform val = _player.characterVisual.footL.Find("skateOffsetL");
			Transform val2 = _player.characterVisual.footR.Find("skateOffsetR");
			if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
			{
				_player.characterVisual.moveStyleProps.skateL.transform.SetLocalPositionAndRotation(val.localPosition, val.localRotation);
				_player.characterVisual.moveStyleProps.skateL.transform.localScale = val.localScale;
				_player.characterVisual.moveStyleProps.skateR.transform.SetLocalPositionAndRotation(val2.localPosition, val2.localRotation);
				_player.characterVisual.moveStyleProps.skateR.transform.localScale = val2.localScale;
			}
		}

		private void OnSkinLoadFinished()
		{
			UnloadShownStreamedCharacter();
			StreamedCharacter = new StreamedCharacterInstance(StreamedCharacterHandle);
			StreamedCharacter.Outfit = StreamedOutfit;
			if (!StreamedCharacter.Handle.Failed && (Object)(object)StreamedCharacter.Handle.CharacterPrefab != (Object)null)
			{
				ApplyStreamedCharacter();
			}
			SkinLoaded?.Invoke();
		}

		public void MakeLOD()
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: 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)
			Material lODMaterial = MPAssets.Instance.LODMaterial;
			Renderer[] componentsInChildren = ((Component)_player.characterVisual).GetComponentsInChildren<Renderer>(true);
			_player.anim.cullingMode = (AnimatorCullingMode)2;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				bool flag = true;
				if (val.sharedMaterials != null && val.sharedMaterials.Length != 0)
				{
					int num = val.sharedMaterials.Length;
					Material[] array2 = (Material[])(object)new Material[num];
					for (int j = 0; j < num; j++)
					{
						array2[j] = lODMaterial;
						if (!((Object)(object)val.sharedMaterials[j] != (Object)null))
						{
							continue;
						}
						if (val.sharedMaterials[j].renderQueue < 3000)
						{
							flag = false;
						}
						MaterialPropertyBlock val2 = new MaterialPropertyBlock();
						if (val.sharedMaterials[j].HasProperty(MainTexId))
						{
							Texture texture = val.sharedMaterials[j].GetTexture(MainTexId);
							if ((Object)(object)texture != (Object)null)
							{
								val2.SetTexture(MainTexId, texture);
							}
						}
						if (val.sharedMaterials[j].HasProperty(ColorId))
						{
							Color color = val.sharedMaterials[j].GetColor(ColorId);
							val2.SetColor(ColorId, color);
						}
						val.SetPropertyBlock(val2, j);
					}
					if (flag && (Object)(object)val != (Object)(object)_player.characterVisual.mainRenderer)
					{
						val.forceRenderingOff = true;
						val.enabled = false;
					}
					val.sharedMaterials = array2;
				}
				val.shadowCastingMode = (ShadowCastingMode)0;
				val.motionVectorGenerationMode = (MotionVectorGenerationMode)2;
				SkinnedMeshRenderer val3 = (SkinnedMeshRenderer)(object)((val is SkinnedMeshRenderer) ? val : null);
				if ((Object)(object)val3 != (Object)null)
				{
					val3.quality = (SkinQuality)1;
				}
				Component[] array3 = CollectionExtensions.AddRangeToArray<Component>(((Component)_player.characterVisual).GetComponentsInChildren(typeof(DynamicBone), true), ((Component)_player.characterVisual).GetComponentsInChildren(typeof(DynamicBoneCollider), true));
				for (int k = 0; k < array3.Length; k++)
				{
					Object.Destroy((Object)(object)array3[k]);
				}
				InverseKinematicsRelay component = ((Component)_player.anim).GetComponent<InverseKinematicsRelay>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
			}
		}
	}
	public class PlayerInListUI : MonoBehaviour
	{
		private TextMeshProUGUI _label;

		private Button _spectateButton;

		private Button _banButton;

		private Button _inviteButton;

		private Button _kickButton;

		private MPPlayer _player;

		private GameObject _afkIndicator;

		private void Awake()
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			_label = ((Component)((Component)this).transform.Find("Name")).GetComponent<TextMeshProUGUI>();
			((TMP_Text)_label).spriteAsset = MPAssets.Instance.Sprites;
			_spectateButton = ((Component)((Component)this).transform.Find("Spectate Button")).GetComponent<Button>();
			_banButton = ((Component)((Component)this).transform.Find("Ban Button")).GetComponent<Button>();
			_inviteButton = ((Component)((Component)this).transform.Find("Invite Button")).GetComponent<Button>();
			_kickButton = ((Component)((Component)this).transform.Find("Kick Button")).GetComponent<Button>();
			((UnityEvent)_spectateButton.onClick).AddListener(new UnityAction(TrySpectate));
			((UnityEvent)_banButton.onClick).AddListener(new UnityAction(TryBan));
			((UnityEvent)_inviteButton.onClick).AddListener(new UnityAction(TryInvite));
			((UnityEvent)_kickButton.onClick).AddListener(new UnityAction(TryKick));
			_afkIndicator = ((Component)((Component)this).transform.Find("AFK")).gameObject;
		}

		private void Update()
		{
			if (_player == null || _player.ClientVisualState == null)
			{
				return;
			}
			_afkIndicator.SetActive(_player.ClientVisualState.AFK);
			ClientController instance = ClientController.Instance;
			Lobby currentLobby = instance.ClientLobbyManager.CurrentLobby;
			if (currentLobby != null && currentLobby.LobbyState.HostId == instance.LocalID && !currentLobby.InGame && _player.ClientId != instance.LocalID && !currentLobby.LobbyState.Players.ContainsKey(_player.ClientId))
			{
				((Component)_inviteButton).gameObject.SetActive(true);
				if (currentLobby.LobbyState.InvitedPlayers.ContainsKey(_player.ClientId))
				{
					((Selectable)_inviteButton).interactable = false;
				}
				else
				{
					((Selectable)_inviteButton).interactable = true;
				}
			}
			else
			{
				((Component)_inviteButton).gameObject.SetActive(false);
			}
			if (currentLobby != null && currentLobby.LobbyState.HostId == instance.LocalID && _player.ClientId != instance.LocalID && currentLobby.LobbyState.Players.ContainsKey(_player.ClientId))
			{
				((Component)_kickButton).gameObject.SetActive(true);
			}
			else
			{
				((Component)_kickButton).gameObject.SetActive(false);
			}
		}

		public void SetPlayer(MPPlayer player)
		{
			ClientController instance = ClientController.Instance;
			_player = player;
			string text = MPUtility.GetPlayerDisplayName(player.ClientState);
			AuthUser localUser = instance.GetLocalUser();
			if (localUser != null && localUser.IsModerator)
			{
				text = $"[{player.ClientId}] {text}";
			}
			((TMP_Text)_label).text = text;
			ushort localID = instance.LocalID;
			((Component)_banButton).gameObject.SetActive(false);
			((Component)_spectateButton).gameObject.SetActive(false);
			if (localID != player.ClientId)
			{
				((Component)_spectateButton).gameObject.SetActive(true);
				if (localUser != null && localUser.IsModerator)
				{
					((Component)_banButton).gameObject.SetActive(true);
				}
			}
		}

		private void TryKick()
		{
			if (_player != null)
			{
				ClientController.Instance.ClientLobbyManager.KickPlayer(_player.ClientId);
			}
		}

		private void TryInvite()
		{
			if (_player != null)
			{
				ClientController.Instance.ClientLobbyManager.InvitePlayer(_player.ClientId);
			}
		}

		private void TrySpectate()
		{
			if (_player != null)
			{
				SpectatorController.StartSpectating(forced: false);
				if (!((Object)(object)SpectatorController.Instance == (Object)null))
				{
					SpectatorController.Instance.SpectatePlayer(_player);
				}
			}
		}

		private void TryBan()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			if (_player != null)
			{
				ClientController.Instance.SendPacket((Packet)new ClientChat($"{'/'}banid {_player.ClientId}"), (SendModes)2, (NetChannels)4);
			}
		}

		public static PlayerInListUI Create(GameObject gameObject)
		{
			GameObject obj = Object.Instantiate<GameObject>(gameObject);
			obj.SetActive(true);
			return obj.AddComponent<PlayerInListUI>();
		}
	}
	public class PlayerInteractable : CustomInteractable
	{
		public MPPlayer Player;

		public bool AlreadyTalked;

		public PlayerSequence Sequence;

		private void Start()
		{
			Sequence = new PlayerSequence(this);
			base.PlacePlayerAtSnapPosition = false;
		}

		private Lobby GetLobby()
		{
			foreach (KeyValuePair<uint, Lobby> lobby in ClientController.Instance.ClientLobbyManager.Lobbies)
			{
				if (lobby.Value.LobbyState.HostId == Player.ClientId)
				{
					return lobby.Value;
				}
			}
			return null;
		}

		private void Update()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			CustomSequenceHandler instance = CustomSequenceHandler.instance;
			if (instance.sequence == Sequence && ((int)currentPlayer.sequenceState == 1 || (int)currentPlayer.sequenceState == 2))
			{
				Lobby lobby = GetLobby();
				if (Player == null || lobby == null || !lobby.LobbyState.Challenge || lobby.LobbyState.InGame)
				{
					Sequence.SaidYes = false;
					instance.ExitCurrentSequence();
				}
			}
			if ((Object)(object)Sequence?.TheirPuppet != (Object)null)
			{
				Sequence.TheirPuppet.LookAtSubject(((Component)currentPlayer).gameObject, ((Component)currentPlayer.characterVisual.head).transform.position);
			}
		}

		private void OnDestroy()
		{
			CustomSequenceHandler instance = CustomSequenceHandler.instance;
			if (!((Object)(object)instance == (Object)null) && (Object)(object)instance != (Object)null && instance.sequence == Sequence && instance.IsInSequence())
			{
				Sequence.SaidYes = false;
				instance.ExitCurrentSequence();
			}
		}

		private void OnDisable()
		{
			CustomSequenceHandler instance = CustomSequenceHandler.instance;
			if (!((Object)(object)instance == (Object)null) && instance.sequence == Sequence && instance.IsInSequence())
			{
				Sequence.SaidYes = false;
				instance.ExitCurrentSequence();
			}
		}

		public override Vector3 GetLookAtPos()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)Player.Player.characterVisual.head).transform.position;
		}

		public override void Interact(Player player)
		{
			CustomSequenceHandler.instance.StartEnteringSequence((CustomSequence)(object)Sequence, (CustomInteractable)(object)this, false, true, false, true, true, true, true, false);
		}

		public static PlayerInteractable Create(MPPlayer player)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive((PrimitiveType)3);
			obj.layer = 19;
			obj.transform.SetParent(((Component)player.Player).transform, false);
			obj.transform.SetLocalPositionAndRotation(new Vector3(0f, 0.5f, 0f), Quaternion.identity);
			obj.transform.localScale = new Vector3(3f, 3f, 3f);
			((Collider)obj.GetComponent<BoxCollider>()).isTrigger = true;
			PlayerInteractable playerInteractable = obj.AddComponent<PlayerInteractable>();
			playerInteractable.Player = player;
			return playerInteractable;
		}
	}
	public class PlayerListUI : MonoBehaviour
	{
		private GameObject _playerReferenceObject;

		private GameObject _window;

		private ScrollRect _scrollRect;

		private List<PlayerInListUI> _playerUIPool = new List<PlayerInListUI>();

		private List<PlayerInListUI> _playerUIInUse = new List<PlayerInListUI>();

		public static PlayerListUI Instance { get; private set; }

		public bool Displaying
		{
			get
			{
				return _window.activeSelf;
			}
			set
			{
				if (Displaying == value)
				{
					return;
				}
				if (!value)
				{
					Cursor.visible = false;
					Cursor.lockState = (CursorLockMode)1;
					GameInput gameInput = Core.Instance.GameInput;
					gameInput.DisableAllControllerMaps(0);
					gameInput.EnableControllerMaps(BaseModule.IN_GAME_INPUT_MAPS, 0);
					if ((Object)(object)SpectatorController.Instance != (Object)null)
					{
						gameInput.EnableControllerMaps(BaseModule.MENU_INPUT_MAPS, 0);
					}
				}
				else
				{
					Core.Instance.GameInput.DisableAllControllerMaps(0);
				}
				_window.SetActive(value);
			}
		}

		private void Awake()
		{
			Instance = this;
			Transform val = ((Component)this).transform.Find("Canvas");
			_window = ((Component)val.Find("Player List Window")).gameObject;
			Transform val2 = _window.transform.Find("Scroll View");
			_scrollRect = ((Component)val2).gameObject.GetComponent<ScrollRect>();
			_playerReferenceObject = ((Component)val2.Find("Viewport").Find("Content").Find("Player")).gameObject;
			_playerReferenceObject.SetActive(false);
			Displaying = false;
			ClientController.ClientStatesUpdate = (Action)Delegate.Combine(ClientController.ClientStatesUpdate, new Action(UpdatePlayers));
			ClientController.ServerDisconnect = (Action)Delegate.Combine(ClientController.ServerDisconnect, new Action(UpdatePlayers));
		}

		private void OnDestroy()
		{
			ClientController.ClientStatesUpdate = (Action)Delegate.Remove(ClientController.ClientStatesUpdate, new Action(UpdatePlayers));
			ClientController.ServerDisconnect = (Action)Delegate.Remove(ClientController.ServerDisconnect, new Action(UpdatePlayers));
		}

		private void Update()
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			if (Displaying)
			{
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
				InputUtils.Override = true;
				try
				{
					if (Input.GetKeyDown(MPSettings.Instance.PlayerListKey) || Input.GetKeyDown((KeyCode)27))
					{
						Displaying = false;
					}
				}
				finally
				{
					InputUtils.Override = false;
				}
				if ((Input.GetMouseButtonDown(0) || Input.GetMouseButtonDown(1) || Input.GetMouseButtonDown(2)) && !RectTransformUtility.RectangleContainsScreenPoint(GameObjectExtensions.RectTransform(_window), Vector2.op_Implicit(Input.mousePosition)))
				{
					Displaying = false;
				}
			}
			else if (Input.GetKeyDown(MPSettings.Instance.PlayerListKey) && CanOpen())
			{
				Displaying = true;
				UpdatePlayers();
			}
		}

		private bool CanOpen()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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)
			if (ChatUI.Instance.State == ChatUI.States.Focused)
			{
				return false;
			}
			PlayerControllerMapIDCollection allCurrentEnabledControllerMapCategoryIDs = Core.Instance.gameInput.GetAllCurrentEnabledControllerMapCategoryIDs(0);
			if (allCurrentEnabledControllerMapCategoryIDs.controllerMapCategoryIDs.Contains(0) && allCurrentEnabledControllerMapCategoryIDs.controllerMapCategoryIDs.Contains(6))
			{
				return !Core.Instance.IsCorePaused;
			}
			return false;
		}

		private void UpdatePlayers()
		{
			if (!Displaying)
			{
				return;
			}
			foreach (PlayerInListUI item in _playerUIInUse)
			{
				PutInPlayerPool(item);
			}
			_playerUIInUse.Clear();
			foreach (MPPlayer item2 in ClientController.Instance.Players.Values.OrderBy((MPPlayer k) => k.ClientId))
			{
				PlayerInListUI playerInListUI = CreateOrGetFromPlayerPool();
				playerInListUI.SetPlayer(item2);
				((Component)playerInListUI).transform.SetAsFirstSibling();
			}
		}

		private PlayerInListUI CreateOrGetFromPlayerPool()
		{
			PlayerInListUI playerInListUI = null;
			if (_playerUIPool.Count > 0)
			{
				playerInListUI = _playerUIPool[0];
				((Component)playerInListUI).gameObject.SetActive(true);
				_playerUIPool.RemoveAt(0);
				_playerUIInUse.Add(playerInListUI);
				return playerInListUI;
			}
			playerInListUI = CreatePlayerUI();
			_playerUIInUse.Add(playerInListUI);
			return playerInListUI;
		}

		private void PutInPlayerPool(PlayerInListUI ui)
		{
			((Component)ui).gameObject.SetActive(false);
			_playerUIPool.Add(ui);
		}

		private PlayerInListUI CreatePlayerUI()
		{
			PlayerInListUI playerInListUI = PlayerInListUI.Create(_playerReferenceObject);
			((Component)playerInListUI).transform.SetParent((Transform)(object)_scrollRect.content, false);
			return playerInListUI;
		}

		public static void Create()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			GameObject obj = Object.Instantiate<GameObject>(MPAssets.Instance.Bundle.LoadAsset<GameObject>("Player List UI"));
			obj.transform.SetParent(((Component)Core.Instance.UIManager).transform, false);
			obj.AddComponent<PlayerListUI>();
		}
	}
	public class PlayerSequence : CustomSequence
	{
		[CompilerGenerated]
		private sealed class <UpdateCamDelayed>d__28 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerSequence <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <UpdateCamDelayed>d__28(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				PlayerSequence playerSequence = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					playerSequence.UpdateCameraPosition();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private PlayerInteractable _interactable;

		private const string MyCrew = "<color=yellow>{0}</color>";

		private const string TheirCrew = "<color=yellow>{1}</color>";

		private const string Gamemode = "<color=yellow>{2}</color>";

		public bool SaidYes;

		public CharacterVisual TheirPuppet;

		private Vector3 _myPosition;

		private Quaternion _myRotation;

		private GameObject _cam;

		private string[] RivalCrewsIntros = new string[6] { "<color=yellow>{0}</color>, huh? I'm with <color=yellow>{1}</color>.", "What's up? You're <color=yellow>{0}</color>? I'm with <color=yellow>{1}</color>.", "Hey. You're <color=yellow>{0}</color>, right? I'm representing <color=yellow>{1}</color>.", "I'm thinking <color=yellow>{1}</color> are gonna put <color=yellow>{0}</color> in their place. What do you think?", "<color=yellow>{1}</color> own this spot, kid. What's <color=yellow>{0}</color> gonna do about it?", "<color=yellow>{0}</color> got nothing on <color=yellow>{1}</color>, I'll show you!" };

		private string[] MyCrewIntros = new string[5] { "Yo! I think <color=yellow>{0}</color> got something to prove.", "I'd love to see how good <color=yellow>{0}</color> really are.", "Let's see what's the best <color=yellow>{0}</color> got to offer.", "Are <color=yellow>{0}</color> looking for something to do? I've got an idea.", "I've heard <color=yellow>{0}</color> doesn't back out of a challenge." };

		private string[] GenericIntros = new string[4] { "How's it hanging? Down for a challenge?", "What's up? I'd like to see what you got.", "Hey! I'm bored. Let's do something.", "Yo! Down to hang out?" };

		private string[] FriendlyIntros = new string[3] { "Hi! Let's kick it!", "Hey! Let's hang out.", "How about some friendly competition?" };

		private string[] ComeBackIntro = new string[3] { "Changed your mind?", "You're ready now?", "Come on! It'll be fun." };

		private string[] GamemodeDialogues = new string[4] { "Down for a <color=yellow>{2}</color>?", "Let's do a <color=yellow>{2}</color>!", "<color=yellow>{2}</color>. Let's do it.", "How about a <color=yellow>{2}</color>?" };

		private string[] YesOutros = new string[5] { "Let's hit it then!", "Let's do it!", "Sick! Let's do it.", "Sweet.", "Dope, let's go!" };

		private string[] NoOutros = new string[6] { "Maybe next time then.", "Sucks.", "Awh... shame.", "That's too bad.", "Laaameeee.", "Boring." };

		private string[] DeadDialogues = new string[3] { "...", "This person's hella dead.", "I don't think this guy's getting up." };

		private const float DistanceToPuppet = 1f;

		private static int GroundMask = 1;

		private static int ObstructionMask = 10494977;

		private static float ObstructionHeight = 1f;

		public PlayerSequence(PlayerInteractable interactable)
		{
			_interactable = interactable;
		}

		private void JoinOtherPlayer()
		{
			ClientController instance = ClientController.Instance;
			Lobby lobby = null;
			foreach (KeyValuePair<uint, Lobby> lobby2 in instance.ClientLobbyManager.Lobbies)
			{
				if (lobby2.Value.LobbyState.HostId == _interactable.Player.ClientId)
				{
					lobby = lobby2.Value;
					break;
				}
			}
			if (lobby != null && instance.ClientLobbyManager.CurrentLobby?.LobbyState.Id != lobby.LobbyState.Id)
			{
				instance.ClientLobbyManager.JoinLobby(lobby.LobbyState.Id);
			}
		}

		public override void Stop()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			((CustomSequence)this).Stop();
			MPUtility.PlaceCurrentPlayer(_myPosition, _myRotation);
			if ((Object)(object)TheirPuppet != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)TheirPuppet).gameObject);
			}
			if ((Object)(object)_cam != (Object)null)
			{
				Object.Destroy((Object)(object)_cam);
			}
			if (SaidYes)
			{
				JoinOtherPlayer();
			}
			GameInput gameInput = Core.Instance.GameInput;
			gameInput.DisableAllControllerMaps(0);
			gameInput.EnableControllerMaps(BaseModule.IN_GAME_INPUT_MAPS, 0);
		}

		private Vector3 GetBestPlayerPosition()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: 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)
			//IL_01fd: 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_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			Vector3 reference = ((Component)TheirPuppet).transform.position + ((Component)TheirPuppet).transform.forward * 1f + Vector3.up * 1f;
			Vector3 reference2 = ((Component)TheirPuppet).transform.position + ((Component)TheirPuppet).transform.forward * 1f + ((Component)TheirPuppet).transform.right * 1f + Vector3.up * 1f;
			Vector3 reference3 = ((Component)TheirPuppet).transform.position + ((Component)TheirPuppet).transform.forward * 1f - ((Component)TheirPuppet).transform.right * 1f + Vector3.up * 1f;
			Vector3 reference4 = ((Component)TheirPuppet).transform.position + ((Component)TheirPuppet).transform.right * 1f + Vector3.up * 1f;
			Vector3 reference5 = ((Component)TheirPuppet).transform.position - ((Component)TheirPuppet).transform.right * 1f + Vector3.up * 1f;
			if (GetValidPosition(reference, out var result))
			{
				return result;
			}
			if (GetValidPosition(reference2, out var result2))
			{
				return result2;
			}
			if (GetValidPosition(reference3, out var result3))
			{
				return result3;
			}
			if (GetValidPosition(reference4, out var result4))
			{
				return result4;
			}
			if (GetValidPosition(reference5, out var result5))
			{
				return result5;
			}
			if (GetValidPosition(((Component)currentPlayer).transform.position + Vector3.up * 1f, out var result6))
			{
				return result6;
			}
			return ((Component)currentPlayer).transform.position;
		}

		private bool GetValidPosition(Vector3 reference, out Vector3 result)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(new Ray(reference, Vector3.down), ref val, 5f, GroundMask))
			{
				Vector3 val2 = ((RaycastHit)(ref val)).point + Vector3.up * ObstructionHeight;
				Vector3 val3 = ((Component)TheirPuppet).transform.position + Vector3.up * ObstructionHeight - val2;
				Vector3 normalized = ((Vector3)(ref val3)).normalized;
				RaycastHit val4 = default(RaycastHit);
				if (!Physics.Raycast(new Ray(val2, normalized), ref val4, ((Vector3)(ref val3)).magnitude, ObstructionMask))
				{
					result = ((RaycastHit)(ref val)).point;
					return true;
				}
			}
			result = reference;
			return false;
		}

		private void CreatePuppets()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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)
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			GameObject val = Object.Instantiate<GameObject>(((Component)_interactable.Player.Player.characterVisual).gameObject);
			val.gameObject.SetActive(true);
			val.transform.SetPositionAndRotation(((Component)_interactable.Player.Player).transform.position, ((Component)_interactable.Player.Player).transform.rotation);
			TheirPuppet = val.GetComponent<CharacterVisual>();
			_myPosition = ((Component)currentPlayer).transform.position;
			_myRotation = ((Component)currentPlayer).transform.rotation;
			Vector3 bestPlayerPosition = GetBestPlayerPosition();
			Vector3 val2 = val.transform.position - bestPlayerPosition;
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			normalized.y = 0f;
			normalized = ((Vector3)(ref normalized)).normalized;
			Quaternion rotation = Quaternion.LookRotation(normalized);
			MPUtility.PlaceCurrentPlayer(bestPlayerPosition, rotation);
			currentPlayer.PlayAnim(Animator.StringToHash("idle"), true, true, -1f);
			TheirPuppet.anim.CrossFade(_interactable.Player.Player.curAnim, 0f, -1, 1f);
			_cam = ((Component)CreateCam()).gameObject;
			UpdateCameraPosition();
			((MonoBehaviour)_interactable).StartCoroutine(UpdateCamDelayed());
			((CustomSequence)this).SetCamera(_cam);
		}

		[IteratorStateMachine(typeof(<UpdateCamDelayed>d__28))]
		private IEnumerator UpdateCamDelayed()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateCamDelayed>d__28(0)
			{
				<>4__this = this
			};
		}

		public void UpdateCameraPosition()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			if (!((Object)(object)_cam == (Object)null) && !((Object)(object)TheirPuppet == (Object)null))
			{
				Vector3 position = TheirPuppet.head.position;
				Vector3 position2 = currentPlayer.characterVisual.head.position;
				Vector3 val = position - position2;
				Vector3 normalized = ((Vector3)(ref val)).normalized;
				Vector3 val2 = Vector3.Cross(normalized, Vector3.up);
				Vector3 val3 = position2 - val2 * 1.25f - Vector3.up * 0.25f - normalized * 1f;
				_cam.transform.position = val3;
				val = position - val3;
				Vector3 normalized2 = ((Vector3)(ref val)).normalized;
				_cam.transform.rotation = Quaternion.LookRotation(normalized2);
			}
		}

		private Camera CreateCam()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Sequence Camera");
			val.gameObject.SetActive(false);
			Camera val2 = val.AddComponent<Camera>();
			val.AddComponent<AudioListener>();
			val.AddComponent<CameraRegisterer>();
			val2.fieldOfView = 50f;
			return val2;
		}

		public override void Play()
		{
			//IL_0126: 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_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Expected O, but got Unknown
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Expected O, but got Unknown
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Expected O, but got Unknown
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Expected O, but got Unknown
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Expected O, but got Unknown
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Invalid comparison between Unknown and I4
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Invalid comparison between Unknown and I4
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			((CustomSequence)this).Play();
			ClientController instance = ClientController.Instance;
			MPPlayer mPPlayer = instance.Players[instance.LocalID];
			Lobby lobby = null;
			foreach (KeyValuePair<uint, Lobby> lobby2 in instance.ClientLobbyManager.Lobbies)
			{
				if (lobby2.Value.LobbyState.HostId == _interactable.Player.ClientId)
				{
					lobby = lobby2.Value;
					break;
				}
			}
			if (lobby == null)
			{
				return;
			}
			string text = TMPFilter.RemoveAllTags(MPUtility.GetCrewDisplayName(mPPlayer.ClientState.CrewName)).Trim();
			string text2 = TMPFilter.RemoveAllTags(MPUtility.GetCrewDisplayName(_interactable.Player.ClientState.CrewName)).Trim();
			string text3 = MPUtility.RemoveCrewTag(TMPFilter.RemoveAllTags(MPUtility.GetPlayerDisplayName(_interactable.Player.ClientState.Name))).Trim();
			string text4 = MPUtility.RemoveCrewTag(TMPFilter.RemoveAllTags(MPUtility.GetPlayerDisplayName(mPPlayer.ClientState.Name))).Trim();
			string gamemodeName = GamemodeFactory.GetGamemodeName(lobby.LobbyState.Gamemode);
			List<string> list = new List<string>();
			if (_interactable.AlreadyTalked)
			{
				list.AddRange(ComeBackIntro);
			}
			else if (string.IsNullOrWhiteSpace(text) && string.IsNullOrWhiteSpace(text2))
			{
				list.AddRange(GenericIntros);
			}
			else if (!string.IsNullOrWhiteSpace(text) && string.IsNullOrWhiteSpace(text2))
			{
				list.AddRange(MyCrewIntros);
			}
			else if (!string.IsNullOrWhiteSpace(text) && !string.IsNullOrWhiteSpace(text2) && text == text2)
			{
				list.AddRange(FriendlyIntros);
				list.AddRange(GenericIntros);
			}
			else if (!string.IsNullOrWhiteSpace(text) && !string.IsNullOrWhiteSpace(text2) && text != text2)
			{
				list.AddRange(RivalCrewsIntros);
			}
			else
			{
				list.AddRange(GenericIntros);
			}
			string text5 = string.Format(list[Random.Range(0, list.Count)], text, text2, gamemodeName);
			string text6 = string.Format(GamemodeDialogues[Random.Range(0, GamemodeDialogues.Length)], text, text2, gamemodeName);
			string text7 = YesOutros[Random.Range(0, YesOutros.Length)];
			string text8 = NoOutros[Random.Range(0, NoOutros.Length)];
			string text9 = DeadDialogues[Random.Range(0, DeadDialogues.Length)];
			CustomDialogue yesDialogue = new CustomDialogue(text3, text7, (CustomDialogue)null)
			{
				EndSequenceOnFinish = true
			};
			CustomDialogue noDialogue = new CustomDialogue(text3, text8, (CustomDialogue)null)
			{
				EndSequenceOnFinish = true
			};
			CustomDialogue questionDialogue = new CustomDialogue(text3, text6, (CustomDialogue)null);
			CustomDialogue val = new CustomDialogue(text3, text5, questionDialogue);
			CustomDialogue val2 = new CustomDialogue(text4, text9, (CustomDialogue)null)
			{
				EndSequenceOnFinish = true
			};
			questionDialogue.OnDialogueBegin = delegate
			{
				_interactable.AlreadyTalked = true;
				((CustomSequence)this).RequestYesNoPrompt();
			};
			questionDialogue.OnDialogueEnd = delegate
			{
				if (questionDialogue.AnsweredYes)
				{
					SaidYes = true;
					((CustomSequence)this).StartDialogue(yesDialogue, 0.9f);
				}
				else
				{
					SaidYes = false;
					((CustomSequence)this).StartDialogue(noDialogue, 0.9f);
				}
			};
			CreatePuppets();
			if ((int)_interactable.Player.ClientVisualState.State != 3)
			{
				AudioManager audioManager = Core.Instance.AudioManager;
				if ((Object)(object)_interactable.Player.PlayerComponent != (Object)null && (int)_interactable.Player.PlayerComponent.SpecialSkin != -1)
				{
					AudioClip random = SpecialSkinManager.Instance.GetAudioLibrary(_interactable.Player.PlayerComponent.SpecialSkin).GetRandom((AudioClipID)486);
					if ((Object)(object)random != (Object)null)
					{
						audioManager.PlayNonloopingSfx(audioManager.audioSources[5], random, audioManager.mixerGroups[5], 0f);
					}
				}
				else if ((Object)(object)_interactable.Player.PlayerComponent != (Object)null && _interactable.Player.PlayerComponent.StreamedCharacter != null)
				{
					AudioClip random2 = _interactable.Player.PlayerComponent.StreamedCharacter.Handle.AudioLibrary.GetRandom((AudioClipID)486);
					if ((Object)(object)random2 != (Object)null)
					{
						audioManager.PlayNonloopingSfx(audioManager.audioSources[5], random2, audioManager.mixerGroups[5], 0f);
					}
				}
				else
				{
					try
					{
						audioManager.PlayVoice(_interactable.Player.Player.character, (AudioClipID)486);
					}
					catch (Exception)
					{
					}
				}
				((CustomSequence)this).StartDialogue(val, 0.9f);
				SaidYes = true;
			}
			else
			{
				((CustomSequence)this).StartDialogue(val2, 0.9f);
				SaidYes = false;
			}
		}
	}
	public static class ProfanityFilter
	{
		public const string CensoredMessage = "I said a naughty word!";

		public const string ProfanityError = "Your message contains banned words.";

		public const string CensoredStatus = "I said a naughty word!";

		public const string StatusProfanityError = "Your status contains banned words.";

		public const string CensoredName = "Punished Slopper";

		public const string FilteredIndicator = "<sprite=37><color=red>[FILTERED]</color>";

		private static List<string> BannedContent = LoadBannedContent();

		private static List<string> SafeWords = LoadSafeWords();

		private static List<string> BadWords = LoadBadWords();

		private static List<string> LoadBadWords()
		{
			List<string> list = new List<string>();
			string[] array = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("BombRushMP.Plugin.res.badwords.txt") ?? throw new Exception("Could not load bad words for profanity filter")).ReadToEnd().Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (!text.StartsWith("#"))
				{
					text = RemoveSpecialCharacters(text);
					text = SpecialCharactersToLetters(text);
					list.Add(text);
				}
			}
			return list;
		}

		private static List<string> LoadSafeWords()
		{
			List<string> list = new List<string>();
			string[] array = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("BombRushMP.Plugin.res.safewords.txt") ?? throw new Exception("Could not load safe words for profanity filter")).ReadToEnd().Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (!text.StartsWith("#"))
				{
					text = RemoveSpecialCharacters(text);
					text = SpecialCharactersToLetters(text);
					list.Add(text);
				}
			}
			return list;
		}

		private static List<string> LoadBannedContent()
		{
			List<string> list = new List<string>();
			string[] array = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("BombRushMP.Plugin.res.profanity.txt") ?? throw new Exception("Could not load profanity filter")).ReadToEnd().Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (!text.StartsWith("#"))
				{
					text = RemoveSpecialCharacters(text);
					text = SpecialCharactersToLetters(text);
					list.Add(text);
				}
			}
			return list;
		}

		public static bool ContainsBadWords(string text)
		{
			text = text.ToLower();
			foreach (string badWord in BadWords)
			{
				if (text == badWord)
				{
					return true;
				}
				if (text.StartsWith(badWord + " "))
				{
					return true;
				}
				if (text.EndsWith(" " + badWord))
				{
					return true;
				}
				if (text.Contains(" " + badWord + " "))
				{
					return true;
				}
			}
			return false;
		}

		public static string RemoveSafeWords(string text)
		{
			text = text.ToLower();
			foreach (string safeWord in SafeWords)
			{
				if (text == safeWord)
				{
					return "";
				}
				text = text.Replace(" " + safeWord + " ", "");
				if (text.StartsWith(safeWord + " "))
				{
					text = text.Substring(safeWord.Length + 1);
				}
				if (text.EndsWith(" " + safeWord))
				{
					text = text.Substring(0, text.Length - safeWord.Length - 1);
				}
			}
			return text;
		}

		public static bool ContainsProfanity(string text)
		{
			foreach (string item in BannedContent)
			{
				if (text.Contains(item.ToLower()))
				{
					return true;
				}
			}
			return false;
		}

		public static bool TMPContainsProfanity(string tmpText)
		{
			string text = AddSpaces(TMPFilter.RemoveAllTags(tmpText));
			string text2 = RemoveRepeatedLetters(text);
			if (ContainsBadWords(text) || ContainsBadWords(text2))
			{
				return true;
			}
			tmpText = RemoveSafeWords(tmpText);
			string text3 = TMPFilter.RemoveAllTags(tmpText);
			text3 = SpecialCharactersToLetters(text3);
			text3 = RemoveSpecialCharacters(text3);
			string text4 = tmpText;
			text4 = SpecialCharactersToLetters(text4);
			text4 = RemoveSpecialCharacters(text4);
			string text5 = RemoveRepeatedLetters(text4);
			string text6 = RemoveRepeatedLetters(text3);
			if (ContainsBadWords(text4) || ContainsBadWords(text3) || ContainsBadWords(text5) || ContainsBadWords(text6))
			{
				return true;
			}
			text4 = RemoveSpaces(text4);
			text3 = RemoveSpaces(text3);
			text5 = RemoveSpaces(text5);
			text6 = RemoveSpaces(text6);
			if (ContainsProfanity(text4) || ContainsProfanity(text3) || ContainsProfanity(text5) || ContainsProfanity(text6))
			{
				return true;
			}
			return false;
		}

		public static string RemoveRepeatedLetters(string text)
		{
			string text2 = "";
			char c = '\0';
			for (int i = 0; i < text.Length; i++)
			{
				char c2 = text[i];
				if (c2 != c)
				{
					c = c2;
					text2 += c2;
				}
			}
			return text2;
		}

		public static string RemoveSpecialCharacters(string text)
		{
			text = new Regex("[^A-Za-z0-9 ]").Replace(text, string.Empty);
			return text;
		}

		public static string AddSpaces(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			return Regex.Replace(Regex.Replace(Regex.Replace(text, "[^a-zA-Z0-9]", (Match m) => " " + m.Value + " "), "(?<=[a-z0-9])(?=[A-Z])", " "), "\\s+", " ").Trim();
		}

		public static string RemoveSpaces(string text)
		{
			return text.Replace(" ", string.Empty);
		}

		public static string SpecialCharactersToLetters(string text)
		{
			text = text.Replace("0", "o");
			text = text.Replace("1", "i");
			text = text.Replace("3", "e");
			text = text.Replace("4", "a");
			text = text.Replace("5", "s");
			text = text.Replace("6", "g");
			text = text.Replace("7", "t");
			text = text.Replace("0", "o");
			text = text.Replace("@", "a");
			return text;
		}
	}
	public class PropHuntPlayer : MonoBehaviour
	{
		private Player _player;

		private GameplayCamera _cam;

		private float _cameraAimAmount;

		private float _spineAimAmount;

		private float _cameraAimSpeed = 20f;

		private float _spineAimSpeed = 10f;

		private bool _aiming;

		private bool _canShoot;

		private float _turnSpeed = 1000f;

		private Vector3 _targetFacing = Vector3.zero;

		private float _backwardsThreshold = -0.1f;

		private float _turnThreshold = 0.2f;

		private float _targetDistance = 20f;

		private int _layerMask = 35689473;

		private GameObject _target;

		private bool _frozen;

		private float _propFireRate = 0.6f;

		private float _hunterFireRate = 0.4f;

		private float _fireTimer;

		private float _timeToLockOnHit = 3f;

		private float _lockedTimer;

		private float _maxFreezeClearance = 8f;

		public bool Frozen => _frozen;

		public bool Aiming => _aiming;

		public float LockedTimer => _lockedTimer;

		public void HitLock()
		{
			_lockedTimer = _timeToLockOnHit;
		}

		private bool CanFreeze()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			return Physics.Raycast(new Ray(((Component)_player).transform.position + Vector3.up * 0.1f, Vector3.down), _maxFreezeClearance, 1025, (QueryTriggerInteraction)1);
		}

		private void FixedUpdate_Prop()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			PropDisguiseController instance = PropDisguiseController.Instance;
			if (!instance.InSetupPhase)
			{
				_ = _player.motor;
				Vector3 val;
				Vector3 val2 = (val = _player.motor.velocity);
				val.y = 0f;
				Vector3 val3 = val2;
				val3.x = 0f;
				val3.z = 0f;
				if (((Vector3)(ref val)).magnitude >= instance.PropHorizontalSpeed)
				{
					val = instance.PropHorizontalSpeed * ((Vector3)(ref val)).normalized;
				}
				if (((Vector3)(ref val3)).magnitude >= instance.PropVerticalSpeed)
				{
					val3 = instance.PropVerticalSpeed * ((Vector3)(ref val3)).normalized;
				}
				_player.motor.velocity = val + val3;
			}
		}

		private void Awake()
		{
			_player = ((Component)this).GetComponent<Player>();
			_cam = GameplayCamera.instance;
		}

		public static PropHuntPlayer GetLocal()
		{
			return ((Component)WorldHandler.instance.GetCurrentPlayer()).GetComponent<PropHuntPlayer>();
		}

		public void Freeze()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (!_frozen)
			{
				_frozen = true;
				_player.motor._rigidbody.isKinematic = true;
				_player.motor._rigidbody.velocity = Vector3.zero;
				_player.motor._rigidbody.rotation = Quaternion.identity;
			}
		}

		public void Unfreeze()
		{
			if (_frozen)
			{
				_frozen = false;
				_player.motor._rigidbody.isKinematic = false;
			}
		}

		private bool IsAimingBackwards(Vector3 forward, float thresh)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)_cam).transform.forward;
			val.y = 0f;
			val = ((Vector3)(ref val)).normalized;
			Vector3 val2 = forward;
			val2.y = 0f;
			val2 = ((Vector3)(ref val2)).normalized;
			if (Vector3.Dot(val, val2) < thresh)
			{
				return true;
			}
			return false;
		}

		private bool PressingMovementKeys()
		{
			return ((Vector3)(ref _player.moveInput)).magnitude > 0f;
		}

		private bool CanTurnToAim()
		{
			if (_player.ability == null && _player.GetTotalSpeed() <= 0.5f)
			{
				return !PressingMovementKeys();
			}
			return false;
		}

		private bool DoHunterShoot()
		{
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: 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_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			bool flag = false;
			float num = 50f;
			PropDisguiseController instance = PropDisguiseController.Instance;
			int hunterPelletAmount = instance.HunterPelletAmount;
			float hunterReticleSize = instance.HunterReticleSize;
			float num2 = hunterReticleSize / (float)hunterPelletAmount;
			float num3 = hunterReticleSize * 0.5f;
			bool result = false;
			HashSet<ushort> hashSet = new HashSet<ushort>();
			XHairUI instance2 = XHairUI.Instance;
			for (int i = 0; i < hunterPelletAmount; i++)
			{
				float num4 = 0f - num3 + num2 * (float)i;
				for (int j = 0; j < hunterPelletAmount; j++)
				{
					float num5 = 0f - num3 + num2 * (float)j;
					GameObject val = CalculateTarget(num4, num5);
					if ((Object)(object)val != (Object)null)
					{
						Player componentInParent = val.GetComponentInParent<Player>();
						if ((Object)(object)componentInParent != (Object)null && componentInParent.isAI)
						{
							MPPlayer muliplayerPlayer = MPUtility.GetMuliplayerPlayer(componentInParent);
							if (muliplayerPlayer != null && !hashSet.Contains(muliplayerPlayer.ClientId) && ClientController.Instance.ClientLobbyManager.CurrentLobby.LobbyState.Players.TryGetValue(muliplayerPlayer.ClientId, out var value) && value.Team == 1)
							{
								hashSet.Add(muliplayerPlayer.ClientId);
								result = true;
								instance2.HitMarkerTime = 0.5f;
								ClientPropHuntShoot packet = new ClientPropHuntShoot(muliplayerPlayer.ClientId);
								ClientController.Instance.SendPacket((Packet)(object)packet, (SendModes)1, (NetChannels)1);
							}
						}
					}
					if (flag)
					{
						Vector3 position = ((Component)_cam).transform.position;
						position += num4 * ((Component)_cam).transform.right;
						position += num5 * ((Component)_cam).transform.up;
						GameObject obj = GameObject.CreatePrimitive((PrimitiveType)3);
						obj.transform.localScale = new Vector3(0.01f, 0.01f, num);
						obj.transform.position = position + ((Component)_cam).transform.forward * (num * 0.5f);
						obj.transform.rotation = ((Component)_cam).transform.rotation;
						Object.Destroy((Object)(object)obj.GetComponent<Collider>());
					}
				}
			}
			return result;
		}

		private GameObject CalculateTarget(float xOffset, float yOffset)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			PropDisguiseController instance = PropDisguiseController.Instance;
			float num = _targetDistance;
			if (instance.LocalPropHuntTeam == PropHuntTeams.Hunters)
			{
				num = float.PositiveInfinity;
			}
			Vector3 position = ((Component)_cam).transform.position;
			position += xOffset * ((Component)_cam).transform.right;
			position += yOffset * ((Component)_cam).transform.up;
			RaycastHit[] array = Physics.RaycastAll(new Ray(position, ((Component)_cam).transform.forward), num, _layerMask, (QueryTriggerInteraction)2);
			GameObject val = null;
			float num2 = float.PositiveInfinity;
			RaycastHit[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				RaycastHit val2 = array2[i];
				PlayerComponent componentInParent = ((Component)((RaycastHit)(ref val2)).collider).gameObject.GetComponentInParent<PlayerComponent>();
				if ((!((Object)(object)componentInParent != (Object)null) || (!((Object)(object)componentInParent.Player == (Object)(object)_player) && (!componentInParent.HasPropDisguise || ((Component)((RaycastHit)(ref val2)).collider).gameObject.layer != 15 || (instance.LocalPropHuntTeam != PropHuntTeams.Props && !((Object)(object)componentInParent.DisguiseGameObject.GetComponentInChildren<StreetLife>() == (Object)null))))) && (instance.LocalPropHuntTeam != 0 || ((Component)((RaycastHit)(ref val2)).collider).gameObject.layer != 25 || !((Object)(object)componentInParent == (Object)null)))
				{
					float num3 = Vector3.Distance(((Component)_cam).transform.position, ((RaycastHit)(ref val2)).point);
					if ((Object)(object)val == (Object)null)
					{
						val = ((Component)((RaycastHit)(ref val2)).collider).gameObject;
						num2 = num3;
					}
					else if (num3 < num2)
					{
						val = ((Component)((RaycastHit)(ref val2)).collider).gameObject;
						num2 = num3;
					}
				}
			}
			return val;
		}

		private void FixedUpdate()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			if (_frozen)
			{
				_player.motor._rigidbody.isKinematic = true;
				_player.motor._rigidbody.velocity = Vector3.zero;
				_player.motor._rigidbody.rotation = Quaternion.identity;
			}
			PropDisguiseController instance = PropDisguiseController.Instance;
			PlayerComponent local = PlayerComponent.GetLocal();
			if (_aiming && CanTurnToAim() && !local.HasPropDisguise)
			{
				Vector3 val = ((Component)_player).transform.forward;
				val.y = 0f;
				val = ((Vector3)(ref val)).normalized;
				float num = Vector3.SignedAngle(val, _targetFacing, Vector3.up);
				_player.SetRotation(((Component)_player).transform.rotation * Quaternion.Euler(0f, Mathf.Clamp(num, (0f - _turnSpeed) * Time.deltaTime, _turnSpeed * Time.deltaTime), 0f));
			}
			if (instance.LocalPropHuntTeam == PropHuntTeams.Props)
			{
				FixedUpdate_Prop();
			}
		}

		private Vector3 GetMaxTurnRotation()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)_player).transform.forward;
			val.y = 0f;
			val = ((Vector3)(ref val)).normalized;
			Vector3 val2 = ((Component)_cam).transform.forward;
			val2.y = 0f;
			val2 = ((Vector3)(ref val2)).normalized;
			float num = Vector3.SignedAngle(val, _targetFacing, Vector3.up);
			Quaternion rotation = ((Component)_player).transform.rotation;
			Vector3 val3 = Quaternion.Euler(0f, ((Quaternion)(ref rotation)).eulerAngles.y + Mathf.Sign(num) * 90f, 0f) * Vector3.forward;
			val3.y = ((Component)_cam).transform.forward.y;
			return ((Vector3)(ref val3)).normalized;
		}

		private void AnimUpdate()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			if (_spineAimAmount > 0f)
			{
				_player.anim.speed = 0f;
				_player.anim.SetFloat(_player.phoneDirectionXHash, (0f - _player.phoneDirBone.localRotation.x) * 2.5f + _player.customPhoneHandValue.x);
				_player.anim.SetFloat(_player.phoneDirectionYHash, (0f - _player.phoneDirBone.localRotation.y) * 2.5f + _player.customPhoneHandValue.y);
				_player.anim.Update(Time.deltaTime);
				_player.anim.speed = 1f;
			}
		}

		private void OnDestroy()
		{
			PropDisguiseController.Instance.OutlineGameObject(null);
			_player.switchToEquippedMovestyleLocked = false;
			Unfreeze();
		}

		private bool CanPlayerAim()
		{
			if (_player.ability == null)
			{
				return true;
			}
			if (_player.ability is BoostAbility)
			{
				return true;
			}
			if (_player.ability is AirDashAbility)
			{
				return true;
			}
			if (_player.ability is SlideAbility && _player.usingEquippedMovestyle)
			{
				return true;
			}
			return false;
		}

		private void LateUpdate()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: 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_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: 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_0242: 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_016b: 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_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: 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_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: 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_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: 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_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			_target = null;
			AnimUpdate();
			bool flag = IsAimingBackwards(((Component)_player).transform.forward, _backwardsThreshold);
			bool flag2 = CanTurnToAim();
			_aiming = _player.sprayButtonHeld;
			_canShoot = false;
			bool flag3 = _player.boostButtonNew;
			if (_lockedTimer > 0f)
			{
				_aiming = false;
				flag3 = false;
			}
			if (_aiming)
			{
				_cameraAimAmount = Mathf.Lerp(_cameraAimAmount, 1f, _cameraAimSpeed * Time.deltaTime);
			}
			else
			{
				_cameraAimAmount = Mathf.Lerp(_cameraAimAmount, 0f, _cameraAimSpeed * Time.deltaTime);
			}
			if (_aiming && CanPlayerAim() && (!flag || flag2))
			{
				_canShoot = true;
				_spineAimAmount = Mathf.Lerp(_spineAimAmount, 1f, _spineAimSpeed * Time.deltaTime);
				_player.anim.Play(_player.canSprayHash, 1, 0.5f);
			}
			else
			{
				_spineAimAmount = Mathf.Lerp(_spineAimAmount, 0f, _spineAimSpeed * Time.deltaTime);
			}
			if (_aiming && IsAimingBackwards(_targetFacing, _turnThreshold) && flag2)
			{
				Vector3 val = ((Component)_cam).transform.forward;
				val.y = 0f;
				val = (_targetFacing = ((Vector3)(ref val)).normalized);
			}
			_player.spraycanLayerWeight = _spineAimAmount;
			_player.anim.SetLayerWeight(1, _spineAimAmount);
			_player.anim.SetLayerWeight(2, _spineAimAmount);
			Vector3 position = ((Component)_player).transform.position;
			position += Vector3.up * 1.5f;
			position += ((Component)_cam).transform.right * 0.5f;
			position -= ((Component)_cam).transform.forward * 1f;
			Vector3 val2 = ((Component)_cam).transform.forward;
			if (flag)
			{
				val2 = GetMaxTurnRotation();
			}
			Transform parent = _player.characterVisual.head.parent.parent;
			Vector3 val3 = parent.InverseTransformDirection(val2);
			Quaternion val4 = Quaternion.FromToRotation(Vector3.forward, val3);
			Quaternion val5 = parent.localRotation * val4;
			parent.localRotation = Quaternion.Slerp(parent.localRotation, val5, _spineAimAmount * 0.7f);
			((Component)_cam).transform.position = Vector3.Lerp(((Component)_cam).transform.position, position, _cameraAimAmount);
			if (!_aiming || !flag2 || PressingMovementKeys())
			{
				_targetFacing = ((Component)_player).transform.forward;
				_targetFacing.y = 0f;
				_targetFacing = ((Vector3)(ref _targetFacing)).normalized;
			}
			_player.switchToEquippedMovestyleLocked = _aiming;
			PropDisguiseController instance = PropDisguiseController.Instance;
			if (_canShoot)
			{
				_target = CalculateTarget(0f, 0f);
			}
			if (instance.LocalPropHuntTeam == PropHuntTeams.Props)
			{
				if (_canShoot)
				{
					if ((Object)(object)_target != (Object)null && instance.IndexByProp.TryGetValue(_target, out var value) && instance.SizeByIndex[value] >= instance.PropMinimumSize)
					{
						instance.OutlineGameObject(_target);
					}
					else
					{
						instance.OutlineGameObject(null);
					}
				}
				else
				{
					instance.OutlineGameObject(null);
				}
				if (flag3)
				{
					if (!_frozen)
					{
						if (CanFreeze())
						{
							Freeze();
						}
						else
						{
							ChatUI.Instance.AddMessage("<color=yellow>You're too far off the ground to freeze.</color>");
						}
					}
					else
					{
						Unfreeze();
					}
				}
			}
			else
			{
				instance.OutlineGameObject(null);
			}
			XHairUI instance2 = XHairUI.Instance;
			instance2.CurrentMode = XHairUI.Modes.Off;
			if (_aiming)
			{
				instance2.CurrentMode = XHairUI.Modes.On;
				if (!_canShoot)
				{
					instance2.CurrentMode = XHairUI.Modes.Cross;
				}
			}
			if (_canShoot && _player.switchStyleButtonNew && _fireTimer <= 0f)
			{
				if (instance.LocalPropHuntTeam == PropHuntTeams.Props && (Object)(object)_target != (Object)null && instance.IndexByProp.TryGetValue(_target, out var value2) && instance.SizeByIndex[value2] >= instance.PropMinimumSize)
				{
					PlayerComponent.GetLocal().ApplyPropDisguise(value2);
				}
				if (instance.LocalPropHuntTeam == PropHuntTeams.Hunters && !instance.InSetupPhase)
				{
					_player.AudioManager.PlaySfxGameplay((SfxCollectionID)18, (AudioClipID)335, 0.05f);
					if (!DoHunterShoot())
					{
						_player.ChangeHP(1);
					}
				}
				_fireTimer = ((instance.LocalPropHuntTeam == PropHuntTeams.Hunters) ? _hunterFireRate : _propFireRate);
			}
			if (instance.LocalPropHuntTeam == PropHuntTeams.Hunters)
			{
				_player.boostCharge = _player.maxBoostCharge;
			}
			else
			{
				_player.boostCharge = 0f;
				_player.recoverDamageTimer = 0f;
			}
			if (instance.InSetupPhase)
			{
				_player.ResetHP();
			}
			_fireTimer -= Time.deltaTime;
			if (_fireTimer <= 0f)
			{
				_fireTimer = 0f;
			}
			_lockedTimer -= Time.deltaTime;
			if (_lockedTimer <= 0f)
			{
				_lockedTimer = 0f;
			}
		}
	}
	public class PropHuntUI : MonoBehaviour
	{
		internal static PropHuntUI Instance;

		private TextMeshProUGUI _aimLabel;

		private TextMeshProUGUI _aimGlyph;

		private TextMeshProUGUI _fireLabel;

		private TextMeshProUGUI _fireGlyph;

		private TextMeshProUGUI _turnLabel;

		private TextMeshProUGUI _freezeLabel;

		private TextMeshProUGUI _freezeGlyph;

		private TextMeshProUGUI _unfreezeLabel;

		private TextMeshProUGUI _lockedControlsLabel;

		private void Update()
		{
			//IL_00bc: 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_00cf: Invalid comparison between Unknown and I4
			((Component)_aimLabel).gameObject.SetActive(false);
			((Component)_aimGlyph).gameObject.SetActive(false);
			((Component)_fireLabel).gameObject.SetActive(false);
			((Component)_fireGlyph).gameObject.SetActive(false);
			((Component)_turnLabel).gameObject.SetActive(false);
			((Component)_freezeLabel).gameObject.SetActive(false);
			((Component)_freezeGlyph).gameObject.SetActive(false);
			((Component)_unfreezeLabel).gameObject.SetActive(false);
			((Component)_lockedControlsLabel).gameObject.SetActive(false);
			if (Core.Instance.BaseModule.IsInGamePaused)
			{
				return;
			}
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			if (((int)currentPlayer.phone.state != 0 && (int)currentPlayer.phone.state != 3) || ((Object)(object)SpectatorUI.Instance != (Object)null && ((Component)SpectatorUI.Instance).gameObject.activeSelf))
			{
				return;
			}
			PropHuntPlayer local = PropHuntPlayer.GetLocal();
			if ((Object)(object)local == (Object)null)
			{
				return;
			}
			if (local.LockedTimer > 0f)
			{
				((Component)_lockedControlsLabel).gameObject.SetActive(true);
				((TMP_Text)_lockedControlsLabel).text = "Locked: " + TimerUI.GetTimeString(local.LockedTimer);
				return;
			}
			PropHuntTeams localPropHuntTeam = PropDisguiseController.Instance.LocalPropHuntTeam;
			((Component)_aimLabel).gameObject.SetActive(true);
			((Component)_aimGlyph).gameObject.SetActive(true);
			if (local.Aiming)
			{
				((Component)_fireGlyph).gameObject.SetActive(true);
				if (localPropHuntTeam == PropHuntTeams.Hunters)
				{
					((Component)_fireLabel).gameObject.SetActive(true);
				}
				else
				{
					((Component)_turnLabel).gameObject.SetActive(true);
				}
			}
			if (localPropHuntTeam == PropHuntTeams.Props)
			{
				((Component)_freezeGlyph).gameObject.SetActive(true);
				if (local.Frozen)
				{
					((Component)_unfreezeLabel).gameObject.SetActive(true);
				}
				else
				{
					((Component)_freezeLabel).gameObject.SetActive(true);
				}
			}
		}

		private static TextMeshProUGUI MakeLabel(TextMeshProUGUI reference, string name)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			TMP_FontAsset font = ((TMP_Text)reference).font;
			float fontSize = ((TMP_Text)reference).fontSize;
			Material fontMaterial = ((TMP_Text)reference).fontMaterial;
			TextMeshProUGUI obj = new GameObject(name).AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj).font = font;
			((TMP_Text)obj).fontSize = fontSize;
			((TMP_Text)obj).fontMaterial = fontMaterial;
			((TMP_Text)obj).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)obj).fontStyle = (FontStyles)1;
			((TMP_Text)obj).outlineWidth = 0.2f;
			return obj;
		}

		private static TextMeshProUGUI MakeGlyph(TextMeshProUGUI reference, int actionID)
		{
			TextMeshProUGUI val = MakeLabel(reference, "");
			((Component)val).gameObject.SetActive(false);
			UIButtonGlyphComponent obj = ((Component)val).gameObject.AddComponent<UIButtonGlyphComponent>();
			obj.inputActionID = actionID;
			obj.localizedGlyphTextComponent = val;
			obj.localizedTextComponent = val;
			((Behaviour)obj).enabled = true;
			((Component)val).gameObject.SetActive(true);
			return val;
		}

		internal static void InitializeUI(GameplayUI gameplayUI)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Instance != (Object)null))
			{
				Instance = new GameObject("Prop Hunt UI Root").AddComponent<PropHuntUI>();
				((Component)Instance).transform.SetParent((Transform)(object)((Component)((Component)gameplayUI).transform.parent).GetComponent<RectTransform>(), false);
				Instance.Init();
				Instance.Deactivate();
			}
		}

		private void Init()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: 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_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_0458: Unknown result type (might be due to invalid IL or missing references)
			//IL_047b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0518: Unknown result type (might be due to invalid IL or missing references)
			//IL_056a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0589: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_061d: Unknown result type (might be due to invalid IL or missing references)
			//IL_063c: Unknown result type (might be due to invalid IL or missing references)
			//IL_065b: Unknown result type (might be due to invalid IL or missing references)
			//IL_067e: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = ((Component)Instance).gameObject.AddComponent<RectTransform>();
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			TextMeshProUGUI[] componentsInChildren = ((Component)Core.Instance.UIManager.danceAbilityUI).GetComponentsInChildren<TextMeshProUGUI>(true);
			TextMeshProUGUI val2 = null;
			TextMeshProUGUI[] array = componentsInChildren;
			foreach (TextMeshProUGUI val3 in array)
			{
				if (((Object)((Component)((TMP_Text)val3).transform).gameObject).name == "DanceSelectConfirmText")
				{
					val2 = val3;
				}
			}
			if (!((Object)(object)val2 == (Object)null))
			{
				float num = 100f;
				float num2 = -50f;
				float num3 = 50f;
				float num4 = 75f;
				_aimLabel = MakeLabel(val2, "Aim");
				((TMP_Text)_aimLabel).text = "Aim";
				((TMP_Text)_aimLabel).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_aimLabel).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_aimLabel).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_aimLabel).rectTransform.anchoredPosition = new Vector2(num + num4, num3 + num2);
				((Transform)((TMP_Text)_aimLabel).rectTransform).SetParent((Transform)(object)val, false);
				_aimGlyph = MakeGlyph(val2, 10);
				((TMP_Text)_aimGlyph).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_aimGlyph).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_aimGlyph).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_aimGlyph).rectTransform.anchoredPosition = new Vector2(num, num3 + num2);
				((Transform)((TMP_Text)_aimGlyph).rectTransform).SetParent((Transform)(object)val, false);
				_fireLabel = MakeLabel(val2, "Fire");
				((TMP_Text)_fireLabel).text = "Fire";
				((TMP_Text)_fireLabel).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_fireLabel).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_fireLabel).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_fireLabel).rectTransform.anchoredPosition = new Vector2(num + num4, num3 + num2 * 2f);
				((Transform)((TMP_Text)_fireLabel).rectTransform).SetParent((Transform)(object)val, false);
				_fireGlyph = MakeGlyph(val2, 11);
				((TMP_Text)_fireGlyph).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_fireGlyph).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_fireGlyph).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_fireGlyph).rectTransform.anchoredPosition = new Vector2(num, num3 + num2 * 2f);
				((Transform)((TMP_Text)_fireGlyph).rectTransform).SetParent((Transform)(object)val, false);
				_turnLabel = MakeLabel(val2, "Turn");
				((TMP_Text)_turnLabel).text = "Turn into Prop";
				((TMP_Text)_turnLabel).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_turnLabel).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_turnLabel).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_turnLabel).rectTransform.anchoredPosition = new Vector2(num + num4, num3 + num2 * 2f);
				((Transform)((TMP_Text)_turnLabel).rectTransform).SetParent((Transform)(object)val, false);
				_freezeLabel = MakeLabel(val2, "Freeze");
				((TMP_Text)_freezeLabel).text = "Freeze";
				((TMP_Text)_freezeLabel).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_freezeLabel).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_freezeLabel).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_freezeLabel).rectTransform.anchoredPosition = new Vector2(num + num4, num3 + num2 * 3f);
				((Transform)((TMP_Text)_freezeLabel).rectTransform).SetParent((Transform)(object)val, false);
				_freezeGlyph = MakeGlyph(val2, 18);
				((TMP_Text)_freezeGlyph).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_freezeGlyph).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_freezeGlyph).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_freezeGlyph).rectTransform.anchoredPosition = new Vector2(num, num3 + num2 * 3f);
				((Transform)((TMP_Text)_freezeGlyph).rectTransform).SetParent((Transform)(object)val, false);
				_unfreezeLabel = MakeLabel(val2, "Unfreeze");
				((TMP_Text)_unfreezeLabel).text = "Unfreeze";
				((TMP_Text)_unfreezeLabel).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_unfreezeLabel).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_unfreezeLabel).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_unfreezeLabel).rectTransform.anchoredPosition = new Vector2(num + num4, num3 + num2 * 3f);
				((Transform)((TMP_Text)_unfreezeLabel).rectTransform).SetParent((Transform)(object)val, false);
				_lockedControlsLabel = MakeLabel(val2, "Locked");
				((TMP_Text)_lockedControlsLabel).text = "Locked";
				((TMP_Text)_lockedControlsLabel).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_lockedControlsLabel).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_lockedControlsLabel).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_lockedControlsLabel).rectTransform.anchoredPosition = new Vector2(num + num4, num3 + num2 * 4f);
				((Transform)((TMP_Text)_lockedControlsLabel).rectTransform).SetParent((Transform)(object)val, false);
			}
		}

		public void Activate()
		{
			((Component)this).gameObject.SetActive(true);
		}

		public void Deactivate()
		{
			((Component)this).gameObject.SetActive(false);
		}

		internal static void DestroyUI()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)Instance);
			}
			Instance = null;
		}
	}
	public class BalanceMeter
	{
		public float Current;

		public float CurrentSpeed;

		public float CurrentSensitivity;

		public float BeginSensitivity = 0.25f;

		public float PassiveSensitivityIncrease = 0.1f;

		public float MinimumDirection = 0.1f;

		public float NudgeForce = 6f;

		public BalanceMeter()
		{
			Reset();
		}

		public void Reset()
		{
			Current = 0f;
			CurrentSpeed = 0f;
			CurrentSensitivity = BeginSensitivity;
		}

		public void DoPenalty(float strength, float sensitivityStrength, float minimumBalance)
		{
			if (Mathf.Abs(Current) < minimumBalance)
			{
				if (Current == 0f)
				{
					float num = (((float)Random.Range(0, 2) == 0f) ? 1f : (-1f));
					Current = minimumBalance * num;
				}
				else
				{
					Current += minimumBalance * Mathf.Sign(Current);
				}
			}
			Current *= strength;
			CurrentSpeed *= strength;
			CurrentSensitivity *= sensitivityStrength;
		}

		public void DoSoftReset(float strength)
		{
			Current *= strength;
			CurrentSpeed *= strength;
		}

		public void Nudge(float strength)
		{
			CurrentSpeed += NudgeForce * strength * CurrentSensitivity * Core.dt;
		}

		public void TickActive()
		{
			float num = Current;
			if (Current == 0f)
			{
				if (CurrentSpeed != 0f)
				{
					num = MinimumDirection * Mathf.Sign(CurrentSpeed);
				}
				else
				{
					float num2 = -1f;
					if (Random.Range(0, 2) == 0)
					{
						num2 = 1f;
					}
					num = MinimumDirection * num2;
				}
			}
			else if (Mathf.Abs(Current) < MinimumDirection)
			{
				num = MinimumDirection * Mathf.Sign(Current);
			}
			num *= CurrentSensitivity;
			CurrentSpeed += num * Core.dt;
			Current += CurrentSpeed * Core.dt;
			Current = Mathf.Clamp(Current, -1f, 1f);
			if (Current >= 1f && CurrentSpeed > 0f)
			{
				CurrentSpeed = 0f;
			}
			if (Current <= -1f && CurrentSpeed < 0f)
			{
				CurrentSpeed = 0f;
			}
			CurrentSensitivity += PassiveSensitivityIncrease * Core.dt;
		}
	}
	public class ProSkaterPlayer : MonoBehaviour
	{
		public const float GrindPenaltyTime = 0.125f;

		private const float GrindSoftReset = 0.5f;

		private const float GrindPenalty = 1.25f;

		private const float GrindSensitivityPenalty = 1.1f;

		private const float GrindPenaltyMinimumBalance = 0.2f;

		public const float LeaveGrindSensitivity = 0.0025f;

		public const float ManualPenaltyTime = 0.125f;

		private const float ManualSoftReset = 0.5f;

		private const float ManualPenalty = 1.25f;

		private const float ManualSensitivityPenalty = 1.1f;

		private const float ManualPenaltyMinimumBalance = 0.2f;

		public const float LeaveManualSensitivity = 0.0025f;

		public bool DidGrind;

		public bool DidManual;

		public BalanceMeter GrindBalance = new BalanceMeter();

		public BalanceMeter ManualBalance = new BalanceMeter();

		private Player _player;

		private void Awake()
		{
			_player = ((Component)this).GetComponent<Player>();
		}

		public void OnEndCombo()
		{
			DidGrind = false;
			DidManual = false;
			GrindBalance.Reset();
			ManualBalance.Reset();
		}

		public void PenalizeGrinding()
		{
			GrindBalance.DoPenalty(1.25f, 1.1f, 0.2f);
		}

		public void SoftResetGrinding()
		{
			GrindBalance.DoSoftReset(0.5f);
		}

		public void PenalizeManual()
		{
			ManualBalance.DoPenalty(1.25f, 1.1f, 0.2f);
		}

		public void SoftResetManual()
		{
			ManualBalance.DoSoftReset(0.5f);
		}

		private void HandplantUpdate(HandplantAbility handplantAbility)
		{
			DidGrind = true;
			GrindBalance.TickActive();
			GrindBalance.Nudge(((Ability)handplantAbility).p.moveInputPlain.x);
		}

		public void GrindUpdateTilting(GrindAbility grindAbility)
		{
			DidGrind = true;
			GrindBalance.TickActive();
			GrindBalance.Nudge(((Ability)grindAbility).p.moveInputPlain.x);
			((Ability)grindAbility).p.anim.SetFloat(grindAbility.grindDirectionHash, GrindBalance.Current);
			grindAbility.grindTilt.x = GrindBalance.Current;
			ClientController instance = ClientController.Instance;
			if (!((Object)(object)instance != (Object)null) || instance.ClientLobbyManager == null || instance.ClientLobbyManager.CurrentLobby == null)
			{
				return;
			}
			Lobby currentLobby = instance.ClientLobbyManager.CurrentLobby;
			if (!(currentLobby.CurrentGamemode is ProSkaterScoreBattle proSkaterScoreBattle) || !currentLobby.InGame || !proSkaterScoreBattle.RewardTilting)
			{
				return;
			}
			if (Mathf.Abs(grindAbility.grindTilt.x) > 0.25f)
			{
				grindAbility.grindTiltBuffer.x = grindAbility.grindTilt.x;
				grindAbility.grindTiltBufferTimer = 0.1f;
			}
			if (grindAbility.grindTiltBufferTimer > 0f)
			{
				grindAbility.grindTiltBufferTimer -= Core.dt;
				if (grindAbility.grindTiltBufferTimer <= 0f)
				{
					grindAbility.grindTiltBuffer.x = 0f;
				}
			}
		}

		private void Update()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if (_player.ability != null && (_player.ability is GrindAbility || _player.ability is HandplantAbility) && (GrindBalance.Current >= 1f || GrindBalance.Current <= -1f))
			{
				float current = GrindBalance.Current;
				_player.DropCombo();
				_player.GetHit(0, -((Component)this).transform.right * Mathf.Sign(current), (KnockbackType)1);
			}
		}

		private void FixedUpdate()
		{
			if (!Core.Instance.IsCorePaused && _player.ability != null)
			{
				if (_player.ability is HandplantAbility)
				{
					Ability ability = _player.ability;
					HandplantUpdate((HandplantAbility)(object)((ability is HandplantAbility) ? ability : null));
				}
				if (IsOnManual())
				{
					ManualUpdate();
				}
			}
		}

		public bool IsOnManual()
		{
			if (_player.ability == null)
			{
				return false;
			}
			if (_player.ability is SlideAbility)
			{
				return true;
			}
			if (_player.ability is GroundTrickAbility && _player.IsGrounded())
			{
				return true;
			}
			return false;
		}

		private void ManualUpdate()
		{
			//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_0086: Unknown result type (might be due to invalid IL or missing references)
			DidManual = true;
			ManualBalance.TickActive();
			ManualBalance.Nudge(Core.Instance.GameInput.GetAxis(6, 0));
			if (ManualBalance.Current >= 1f || ManualBalance.Current <= -1f)
			{
				float current = ManualBalance.Current;
				_player.DropCombo();
				_player.GetHit(0, -((Component)this).transform.forward * Mathf.Sign(current), (KnockbackType)1);
			}
			_player.comboTimeOutTimer = 1f;
		}

		public static void Set(Player player, bool set)
		{
			ProSkaterPlayer proSkaterPlayer = Get(player);
			if ((!set || !((Object)(object)proSkaterPlayer != (Object)null)) && (set || !((Object)(object)proSkaterPlayer == (Object)null)))
			{
				if (set)
				{
					((Component)player).gameObject.AddComponent<ProSkaterPlayer>();
				}
				else
				{
					Object.Destroy((Object)(object)proSkaterPlayer);
				}
			}
		}

		public static ProSkaterPlayer Get(Player player)
		{
			return ((Component)player).GetComponent<ProSkaterPlayer>();
		}
	}
	public class ProxyEncounter : Encounter
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static StageInitializationDelegate <0>__OnStagePreInitialization;
		}

		public static ProxyEncounter Instance;

		private const string UID = "3c2af407-bdcc-45af-82e0-ab20104d41a4";

		public static void Initialize()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//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_0020: Expected O, but got Unknown
			StageInitializationDelegate onStagePreInitialization = StageAPI.OnStagePreInitialization;
			object obj = <>O.<0>__OnStagePreInitialization;
			if (obj == null)
			{
				StageInitializationDelegate val = OnStagePreInitialization;
				<>O.<0>__OnStagePreInitialization = val;
				obj = (object)val;
			}
			StageAPI.OnStagePreInitialization = (StageInitializationDelegate)Delegate.Combine((Delegate?)(object)onStagePreInitialization, (Delegate?)obj);
		}

		private static void OnStagePreInitialization(Stage newStage, Stage previousStage)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Instance = new GameObject("BRCMP Proxy Encounter").AddComponent<ProxyEncounter>();
			((AProgressable)Instance).uid = "3c2af407-bdcc-45af-82e0-ab20104d41a4";
		}

		public override void InitSceneObject()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			base.makeUnavailableDuringEncounter = (GameObject[])(object)new GameObject[0];
			base.introSequence = null;
			base.currentCheckpoint = -1;
			base.OnIntro = new UnityEvent();
			base.OnStart = new UnityEvent();
			base.OnOutro = new UnityEvent();
			base.OnCompleted = new UnityEvent();
			base.OnFailed = new UnityEvent();
			((Encounter)this).InitSceneObject();
		}

		public override void SetEncounterState(EncounterState setState)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_0043: Expected I4, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Invalid comparison between Unknown and I4
			base.stateTimer = 0f;
			base.state = setState;
			EncounterState state = base.state;
			switch ((int)state)
			{
			case 0:
				((Encounter)this).EnterEncounterState((EncounterState)0);
				if ((Object)(object)WorldHandler.instance.currentEncounter == (Object)(object)this)
				{
					WorldHandler.instance.MakeStuffAvailableAgainCauseEncounterOver();
				}
				break;
			case 1:
				((Encounter)this).EnterEncounterState((EncounterState)1);
				break;
			case 2:
				if ((int)((GameplayEvent)this).openOn == 1 && ((GameplayEvent)this).requirement != 0)
				{
					WorldHandler.instance.ResetRequiredREP();
				}
				((GameplayEvent)this).requirement = 0;
				if ((Object)(object)((GameplayEvent)this).openingSequence != (Object)null && !base.shownOpening)
				{
					base.handler.StartEnteringSequence(((GameplayEvent)this).openingSequence, (GameplayEvent)(object)this, base.turnOffPlayerDuringSequences, true, false, false, true, (ProgressObject)null, true, base.lowerVolumeDuringSequence, (Battle)null, false);
					break;
				}
				((Encounter)this).EnterEncounterState((EncounterState)2);
				base.shownOpening = true;
				break;
			case 3:
				WorldHandler.instance.StartEncounter((Encounter)(object)this);
				base.currentlyActive = true;
				((Encounter)this).ChangeSkybox(true);
				if ((Object)(object)base.introSequence != (Object)null && base.currentCheckpoint == -1)
				{
					base.handler.StartEnteringSequence(base.introSequence, (GameplayEvent)(object)this, base.turnOffPlayerDuringSequences, true, base.instantIntro, false, base.allowPhone, (ProgressObject)null, true, base.lowerVolumeDuringSequence, (Battle)null, false);
				}
				else
				{
					((Encounter)this).EnterEncounterState((EncounterState)3);
					base.OnIntro.Invoke();
					((Encounter)this).SetEncounterState((EncounterState)4);
					SequenceHandler.instance.LetPlayerExitSequence();
				}
				((AProgressable)this).WriteToData();
				break;
			case 4:
				((Encounter)this).EnterEncounterState((EncounterState)4);
				base.OnStart.Invoke();
				((Encounter)this).StartMainEvent();
				break;
			case 5:
				base.win = true;
				((Encounter)this).EnterEncounterState((EncounterState)5);
				break;
			case 6:
				((Encounter)this).EnterEncounterState((EncounterState)6);
				break;
			case 7:
				if ((Object)(object)base.outroSuccesSequence != (Object)null)
				{
					base.handler.StartEnteringSequence(base.outroSuccesSequence, (GameplayEvent)(object)this, base.turnOffPlayerDuringSequences, true, false, false, true, (ProgressObject)null, true, base.lowerVolumeDuringSequence, (Battle)null, false);
					break;
				}
				((Encounter)this).EnterEncounterState((EncounterState)7);
				base.OnOutro.Invoke();
				if ((Object)(object)WorldHandler.instance.currentEncounter == (Object)(object)this)
				{
					WorldHandler.instance.MakeStuffAvailableAgainCauseEncounterOver();
				}
				((Encounter)this).SetEncounterState((EncounterState)0);
				((Encounter)this).Complete((PlayableDirector)null);
				break;
			case 8:
				if ((Object)(object)base.outroFailSequence != (Object)null)
				{
					base.handler.StartEnteringSequence(base.outroFailSequence, (GameplayEvent)(object)this, base.turnOffPlayerDuringSequences, true, false, false, true, (ProgressObject)null, true, base.lowerVolumeDuringSequence, (Battle)null, false);
					break;
				}
				((Encounter)this).EnterEncounterState((EncounterState)8);
				base.OnOutro.Invoke();
				((Encounter)this).Fail((PlayableDirector)null);
				if (base.restartImmediatelyOnFail)
				{
					((Encounter)this).ActivateEncounterInstantIntro();
					break;
				}
				if ((Object)(object)WorldHandler.instance.currentEncounter == (Object)(object)this)
				{
					WorldHandler.instance.MakeStuffAvailableAgainCauseEncounterOver();
				}
				((Encounter)this).SetEncounterState((EncounterState)0);
				break;
			}
		}

		public override void ReadFromData()
		{
		}

		public override void WriteToData()
		{
		}
	}
	public class PseudoDieAbility : Ability
	{
		private int dieHash = Animator.StringToHash("die");

		public PseudoDieAbility(Player player)
			: base(player)
		{
		}

		public override void Init()
		{
			base.normalMovement = true;
			base.normalRotation = false;
			base.canStartGrind = false;
			base.canStartWallrun = false;
			base.targetSpeed = 0f;
		}

		public override void OnStartAbility()
		{
			base.p.SwitchToEquippedMovestyle(false, false, true, true);
			base.p.StartScreenShake((ScreenShakeType)1, 0.6f, false);
			try
			{
				base.p.PlayVoice((AudioClipID)484, (VoicePriority)4, true);
			}
			catch (Exception)
			{
			}
			base.p.PlayAnim(dieHash, false, false, -1f);
			base.p.RemoveAllCuffs((CuffMissileLauncher)null);
		}
	}
	public static class PvPUtils
	{
		public const string PvPTag = "pvp";

		public const string CantGetHitTag = "canthit";

		public const string NoDamageTag = "nodamage";

		public static bool CanReptilePlayerPvP(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			MPPlayer muliplayerPlayer = MPUtility.GetMuliplayerPlayer(player);
			if (muliplayerPlayer == null)
			{
				return false;
			}
			if (!muliplayerPlayer.ClientState.User.HasTag("pvp"))
			{
				return ClientController.Instance.ServerState.Tags.Contains("pvp");
			}
			return true;
		}

		public static bool CanIGetHit()
		{
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			AuthUser localUser = instance.GetLocalUser();
			if (localUser == null)
			{
				return true;
			}
			return !localUser.HasTag("canthit");
		}

		public static bool CanIGetDamaged()
		{
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			AuthUser localUser = instance.GetLocalUser();
			if (localUser == null)
			{
				return true;
			}
			return !localUser.HasTag("nodamage");
		}

		public static void SetHitboxesFromBits(int bits, Player player)
		{
			int num = 1;
			int num2 = 2;
			int num3 = 4;
			int num4 = 8;
			int num5 = 16;
			int num6 = 32;
			int num7 = 64;
			if ((bits & num) != 0)
			{
				player.hitbox.SetActive(true);
			}
			else
			{
				player.hitbox.SetActive(false);
			}
			if ((bits & num2) != 0)
			{
				player.hitboxLeftLeg.SetActive(true);
			}
			else
			{
				player.hitboxLeftLeg.SetActive(false);
			}
			if ((bits & num3) != 0)
			{
				player.hitboxRightLeg.SetActive(true);
			}
			else
			{
				player.hitboxRightLeg.SetActive(false);
			}
			if ((bits & num4) != 0)
			{
				player.hitboxUpperBody.SetActive(true);
			}
			else
			{
				player.hitboxUpperBody.SetActive(false);
			}
			if ((bits & num5) != 0)
			{
				player.airialHitbox.SetActive(true);
			}
			else
			{
				player.airialHitbox.SetActive(false);
			}
			if ((bits & num6) != 0)
			{
				player.radialHitbox.SetActive(true);
			}
			else
			{
				player.radialHitbox.SetActive(false);
			}
			if ((bits & num7) != 0)
			{
				player.sprayHitbox.SetActive(true);
			}
			else
			{
				player.sprayHitbox.SetActive(false);
			}
		}

		public static int HitboxesToBits(Player player)
		{
			int num = 1;
			int num2 = 2;
			int num3 = 4;
			int num4 = 8;
			int num5 = 16;
			int num6 = 32;
			int num7 = 64;
			int num8 = 0;
			if (player.hitbox.activeSelf)
			{
				num8 |= num;
			}
			if (player.hitboxLeftLeg.activeSelf)
			{
				num8 |= num2;
			}
			if (player.hitboxRightLeg.activeSelf)
			{
				num8 |= num3;
			}
			if (player.hitboxUpperBody.activeSelf)
			{
				num8 |= num4;
			}
			if (player.airialHitbox.activeSelf)
			{
				num8 |= num5;
			}
			if (player.radialHitbox.activeSelf)
			{
				num8 |= num6;
			}
			if (Object.op_Implicit((Object)(object)player.sprayHitbox))
			{
				num8 |= num7;
			}
			return num8;
		}
	}
	public class ReflectionController : MonoBehaviour
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static StageInitializationDelegate <0>__OnStagePreInitialization;
		}

		[CompilerGenerated]
		private sealed class <RenderLowReflection>d__15 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ReflectionController <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RenderLowReflection>d__15(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				ReflectionController reflectionController = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSecondsRealtime(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((Component)reflectionController.Probe).transform.position = WorldHandler.instance.CurrentCameraPosition;
					reflectionController.Probe.RenderProbe();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public Transform Anchor;

		private const int MediumQualityReflectionResolution = 32;

		private static Vector3 PlaceholderLocation = new Vector3(50000f, 50000f, 50000f);

		private static GameObject Prefab;

		public static ReflectionController Instance { get; private set; }

		public ReflectionProbe Probe { get; private set; }

		public static void Initialize()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//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_0039: Expected O, but got Unknown
			Prefab = MPAssets.Instance.Bundle.LoadAsset<GameObject>("Camera Reflection Probe");
			StageInitializationDelegate onStagePreInitialization = StageAPI.OnStagePreInitialization;
			object obj = <>O.<0>__OnStagePreInitialization;
			if (obj == null)
			{
				StageInitializationDelegate val = OnStagePreInitialization;
				<>O.<0>__OnStagePreInitialization = val;
				obj = (object)val;
			}
			StageAPI.OnStagePreInitialization = (StageInitializationDelegate)Delegate.Combine((Delegate?)(object)onStagePreInitialization, (Delegate?)obj);
		}

		private static void OnStagePreInitialization(Stage newStage, Stage previousStage)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new GameObject("Reflection Controller").AddComponent<ReflectionController>();
		}

		private void Awake()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			ReflectionQualities reflectionQuality = MPSettings.Instance.ReflectionQuality;
			GameObject val = new GameObject("Reflection Anchor");
			val.transform.SetPositionAndRotation(PlaceholderLocation, Quaternion.identity);
			Anchor = val.transform;
			if (reflectionQuality != 0)
			{
				Probe = Object.Instantiate<GameObject>(Prefab).GetComponent<ReflectionProbe>();
				if (reflectionQuality == ReflectionQualities.Low)
				{
					Probe.refreshMode = (ReflectionProbeRefreshMode)2;
					((MonoBehaviour)this).StartCoroutine(RenderLowReflection());
				}
				if (reflectionQuality == ReflectionQualities.Medium)
				{
					Probe.resolution = 32;
					Probe.timeSlicingMode = (ReflectionProbeTimeSlicingMode)1;
				}
			}
		}

		[IteratorStateMachine(typeof(<RenderLowReflection>d__15))]
		private IEnumerator RenderLowReflection()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RenderLowReflection>d__15(0)
			{
				<>4__this = this
			};
		}

		private void Update()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Probe == (Object)null))
			{
				Probe.center = PlaceholderLocation;
				((Component)Probe).transform.position = WorldHandler.instance.CurrentCameraPosition;
				((Component)Anchor).transform.position = ((Component)Probe).transform.position + Probe.center;
			}
		}
	}
	public enum ReflectionQualities
	{
		Off,
		Low,
		Medium,
		High
	}
	public static class RenderStats
	{
		public static int Players;

		public static int PlayersCulled;

		public static int PlayersRendered;

		public static int PlayersRenderedLOD;

		public static void Reset()
		{
			Players = 0;
			PlayersCulled = 0;
			PlayersRendered = 0;
			PlayersRenderedLOD = 0;
		}
	}
	public class SpecialSkin
	{
		public string PrefabName = "";

		public SpecialSkin(string prefabName)
		{
			PrefabName = prefabName;
		}
	}
	public class SpecialSkinManager
	{
		private Dictionary<SpecialSkins, string> _specialSkinPrefabs = new Dictionary<SpecialSkins, string>
		{
			{
				(SpecialSkins)0,
				"PlayerFemaleCopPrefab"
			},
			{
				(SpecialSkins)1,
				"PlayerMaleCopPrefab"
			},
			{
				(SpecialSkins)2,
				"SpecialPlayerPrefab"
			},
			{
				(SpecialSkins)3,
				"SeanKingstonPrefab"
			},
			{
				(SpecialSkins)4,
				"ForkliftPrefab"
			},
			{
				(SpecialSkins)5,
				"JillPrefab"
			},
			{
				(SpecialSkins)6,
				"StevePrefab"
			},
			{
				(SpecialSkins)7,
				"XmasRedPrefab"
			},
			{
				(SpecialSkins)8,
				"MinecraftPrefab"
			},
			{
				(SpecialSkins)9,
				"LowTierGodPrefab"
			}
		};

		private Dictionary<SpecialSkins, GameObject> _specialSkinVisuals = new Dictionary<SpecialSkins, GameObject>();

		private Dictionary<SpecialSkins, AudioLibrary> _specialSkinAudio = new Dictionary<SpecialSkins, AudioLibrary>();

		private Dictionary<SpecialSkins, SpecialSkinDefinition> _specialSkinDefinitions = new Dictionary<SpecialSkins, SpecialSkinDefinition>();

		private MPAssets _assets;

		public static SpecialSkinManager Instance { get; private set; }

		public SpecialSkinManager()
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			_assets = MPAssets.Instance;
			foreach (KeyValuePair<SpecialSkins, string> specialSkinPrefab in _specialSkinPrefabs)
			{
				Construct(specialSkinPrefab.Key, specialSkinPrefab.Value);
			}
		}

		private void Construct(SpecialSkins skinEnum, string prefabName)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = _assets.Bundle.LoadAsset<GameObject>(prefabName);
			SpecialSkinDefinition component = obj.GetComponent<SpecialSkinDefinition>();
			AudioLibrary value = AudioLibraryUtils.CreateFromSpecialSkin(component);
			_specialSkinAudio[skinEnum] = value;
			GameObject obj2 = Object.Instantiate<GameObject>(obj);
			GameObject val = new GameObject($"{skinEnum} Visual");
			obj2.transform.SetParent(val.transform, false);
			obj2.transform.SetPositionAndRotation(Vector3.zero, Quaternion.identity);
			Object.DontDestroyOnLoad((Object)(object)val);
			val.SetActive(false);
			_specialSkinVisuals[skinEnum] = val;
			_specialSkinDefinitions[skinEnum] = component;
		}

		public SpecialSkinDefinition GetDefinition(SpecialSkins skin)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (_specialSkinDefinitions.ContainsKey(skin))
			{
				return _specialSkinDefinitions[skin];
			}
			return null;
		}

		public AudioLibrary GetAudioLibrary(SpecialSkins skin)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (_specialSkinAudio.ContainsKey(skin))
			{
				return _specialSkinAudio[skin];
			}
			return null;
		}

		public void RemoveSpecialSkinFromPlayer(Player player)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_0019: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			PlayerComponent playerComponent = PlayerComponent.Get(player);
			if ((int)playerComponent.SpecialSkin != -1)
			{
				playerComponent.UnloadStreamedCharacter();
				playerComponent.SpecialSkin = (SpecialSkins)(-1);
				playerComponent.MainRenderer = null;
				playerComponent.SpecialSkinVariant = -1;
				Characters character = player.character;
				player.character = (Characters)(-1);
				player.SetCharacter(character, Core.Instance.SaveManager.CurrentSaveSlot.GetCharacterProgress(character).outfit);
				player.InitVisual();
				player.usingEquippedMovestyle = false;
				ClientController instance = ClientController.Instance;
				if ((Object)(object)instance != (Object)null && playerComponent.Local)
				{
					instance.SendClientState();
				}
			}
		}

		public void ApplyRandomVariantToPlayer(Player player)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			PlayerComponent playerComponent = PlayerComponent.Get(player);
			if ((int)playerComponent.SpecialSkin != -1 && !((Object)(object)playerComponent.MainRenderer == (Object)null))
			{
				SpecialSkinDefinition definition = GetDefinition(playerComponent.SpecialSkin);
				if (definition.Variants.Length != 0)
				{
					int variant = Random.Range(0, definition.Variants.Length);
					ApplySpecialSkinVariantToPlayer(player, variant);
				}
			}
		}

		public void ApplySpecialSkinVariantToPlayer(Player player, int variant)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			PlayerComponent playerComponent = PlayerComponent.Get(player);
			if ((int)playerComponent.SpecialSkin != -1 && playerComponent.SpecialSkinVariant != variant)
			{
				Material sharedMaterial = GetDefinition(playerComponent.SpecialSkin).Variants[variant];
				((Renderer)playerComponent.MainRenderer).sharedMaterial = sharedMaterial;
				playerComponent.SpecialSkinVariant = variant;
				ClientController instance = ClientController.Instance;
				if ((Object)(object)instance != (Object)null && playerComponent.Local)
				{
					instance.SendClientState();
				}
			}
		}

		public void ApplySpecialSkinToPlayer(Player player, SpecialSkins skin)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000e: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: 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_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			if ((int)skin == -1)
			{
				RemoveSpecialSkinFromPlayer(player);
				return;
			}
			player.character = (Characters)3;
			if ((Object)(object)player.visualTf != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)player.visualTf).gameObject);
			}
			CharacterVisual val = Object.Instantiate<GameObject>(_specialSkinVisuals[skin]).AddComponent<CharacterVisual>();
			val.Init((Characters)(-1), player.animatorController, true, player.motor.groundDetection.groundLimit);
			SpecialSkinDefinition definition = GetDefinition(skin);
			val.canBlink = definition.CanBlink;
			((Component)val).gameObject.SetActive(true);
			player.characterVisual = val;
			player.characterMesh = player.characterVisual.mainRenderer.sharedMesh;
			((Component)player.characterVisual).transform.SetParent(((Component)player).transform.GetChild(0), false);
			((Component)player.characterVisual).transform.localPosition = Vector3.zero;
			((Component)player.characterVisual).transform.rotation = Quaternion.LookRotation(((Component)player).transform.forward);
			((Component)player.characterVisual.anim).gameObject.AddComponent<AnimationEventRelay>().Init();
			player.visualTf = ((Component)player.characterVisual).transform;
			player.headTf = TransformExtentions.FindRecursive(player.visualTf, "head");
			player.phoneDirBone = TransformExtentions.FindRecursive(player.visualTf, "phoneDirection");
			player.heightToHead = (player.headTf.position - player.visualTf.position).y;
			player.isGirl = false;
			player.anim = player.characterVisual.anim;
			if (player.curAnim != 0)
			{
				int curAnim = player.curAnim;
				player.curAnim = 0;
				player.PlayAnim(curAnim, false, false, -1f);
			}
			player.characterVisual.InitVFX(player.VFXPrefabs);
			player.characterVisual.InitMoveStyleProps(player.MoveStylePropsPrefabs);
			player.characterConstructor.SetMoveStyleSkinsForCharacter(player, player.character);
			if (player.characterVisual.hasEffects)
			{
				player.boostpackTrail = player.characterVisual.VFX.boostpackTrail.GetComponent<TrailRenderer>();
				player.boostpackTrailDefaultWidth = player.boostpackTrail.startWidth;
				player.boostpackTrailDefaultTime = player.boostpackTrail.time;
				player.spraypaintParticles = player.characterVisual.VFX.spraypaint.GetComponent<ParticleSystem>();
				player.characterVisual.VFX.spraypaint.transform.localScale = Vector3.one * 0.5f;
				player.SetDustEmission(0);
				player.ringParticles = player.characterVisual.VFX.ring.GetComponent<ParticleSystem>();
				player.SetRingEmission(0);
			}
			bool usingEquippedMovestyle = player.usingEquippedMovestyle;
			player.SetCurrentMoveStyleEquipped(player.moveStyleEquipped, true, true);
			player.InitVisual();
			if (!usingEquippedMovestyle)
			{
				player.SetMoveStyle((MoveStyle)0, true, true, (GameObject)null);
			}
			if (!player.isAI)
			{
				MPSaveData.MPCharacterData characterData = MPSaveData.Instance.GetCharacterData(player.character);
				if (characterData.MPMoveStyleSkin != -1)
				{
					MPUnlockManager instance = MPUnlockManager.Instance;
					if (instance.UnlockByID.ContainsKey(characterData.MPMoveStyleSkin) && instance.UnlockByID[characterData.MPMoveStyleSkin] is MPMoveStyleSkin mPMoveStyleSkin)
					{
						mPMoveStyleSkin.ApplyToPlayer(player);
					}
				}
			}
			PlayerComponent playerComponent = PlayerComponent.Get(player);
			playerComponent.UnloadStreamedCharacter();
			playerComponent.SpecialSkin = skin;
			player.usingEquippedMovestyle = false;
			playerComponent.MainRenderer = null;
			playerComponent.SpecialSkinVariant = -1;
			if (!string.IsNullOrEmpty(definition.MainRendererName))
			{
				playerComponent.MainRenderer = ((Component)TransformExtentions.FindRecursive(player.visualTf, definition.MainRendererName)).GetComponent<SkinnedMeshRenderer>();
				ApplySpecialSkinVariantToPlayer(player, 0);
			}
			ClientController instance2 = ClientController.Instance;
			if ((Object)(object)instance2 != (Object)null && playerComponent.Local)
			{
				instance2.SendClientState();
			}
		}
	}
	public class SpectatorController : MonoBehaviour
	{
		public bool Forced;

		public ushort CurrentSpectatingClient;

		private ClientController _clientController;

		private List<ushort> _players = new List<ushort>();

		private Player _currentSpectatingPlayer;

		private GameplayCamera _gameplayCamera;

		private WorldHandler _worldHandler;

		private GameInput _gameInput;

		private UIManager _uiManager;

		public static SpectatorController Instance { get; private set; }

		private void Awake()
		{
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			ChatUI instance = ChatUI.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.SetState(ChatUI.States.Unfocused);
			}
			_ = PlayerListUI.Instance;
			MPUtility.CloseMenusAndSpectator();
			_uiManager = Core.instance.UIManager;
			_gameInput = Core.Instance.GameInput;
			_worldHandler = WorldHandler.instance;
			Player currentPlayer = _worldHandler.GetCurrentPlayer();
			if (!currentPlayer.userInputEnabled && !Forced)
			{
				EndSpectating();
				return;
			}
			((Component)_uiManager.gameplay).gameObject.SetActive(false);
			_gameInput.DisableAllControllerMaps(0);
			_gameInput.EnableControllerMaps(BaseModule.IN_GAME_INPUT_MAPS, 0);
			_gameInput.EnableControllerMaps(BaseModule.MENU_INPUT_MAPS, 0);
			currentPlayer.phone.TurnOff(false);
			currentPlayer.userInputEnabled = false;
			currentPlayer.SetIgnoreCamInput(true);
			currentPlayer.cam = null;
			currentPlayer.DropCombo();
			currentPlayer.SetVelocity(Vector3.zero);
			currentPlayer.motor._rigidbody.isKinematic = true;
			_gameplayCamera = GameplayCamera.instance;
			_clientController = ClientController.Instance;
			CachePlayers();
			if (_players.Count == 0 && !Forced)
			{
				EndSpectating();
				return;
			}
			CurrentSpectatingClient = _players[0];
			SpectatorUI.Instance.Activate();
		}

		public void SpectatePlayer(MPPlayer player)
		{
			int num = _players.IndexOf(player.ClientId);
			if (num >= 0)
			{
				CurrentSpectatingClient = _players[num];
			}
		}

		public bool CanTeleportToCurrentPlayer()
		{
			if ((Object)(object)_clientController == (Object)null)
			{
				return false;
			}
			AuthUser localUser = _clientController.GetLocalUser();
			if (_clientController.ClientLobbyManager.CurrentLobby != null && _clientController.ClientLobbyManager.CurrentLobby.InGame)
			{
				return false;
			}
			if (localUser != null && localUser.IsModerator)
			{
				return true;
			}
			return _clientController.Players[CurrentSpectatingClient].ClientState.AllowTeleports;
		}

		private void Update()
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			MPSaveData.Instance.Stats.TimeSpentSpectating += Core.dt;
			ClientController.Instance.GetLocalUser();
			CachePlayers();
			if (_players.Count == 0 && !Forced)
			{
				EndSpectating();
				return;
			}
			ushort num = _players[GetCurrentSpectatingIndex()];
			Player val = _worldHandler.GetCurrentPlayer();
			if (num != ClientController.Instance.LocalID)
			{
				val = ClientController.Instance.Players[num].Player;
			}
			if ((Object)(object)_currentSpectatingPlayer != (Object)(object)val)
			{
				if ((Object)(object)_currentSpectatingPlayer != (Object)null)
				{
					_currentSpectatingPlayer.cam = null;
				}
				val.cam = _gameplayCamera;
				_currentSpectatingPlayer = val;
				_gameplayCamera.SetPlayerToFollow(val);
			}
			if (_gameInput.GetButtonNew(2, 0) && CanTeleportToCurrentPlayer() && !Forced)
			{
				EndSpectating();
				MPUtility.PlaceCurrentPlayer(((Component)val).transform.position, ((Component)val).transform.rotation);
				return;
			}
			if (_gameInput.GetButtonNew(3, 0) && !Forced)
			{
				EndSpectating();
				return;
			}
			if (_gameInput.GetButtonNew(57, 0))
			{
				Previous();
			}
			if (_gameInput.GetButtonNew(29, 0))
			{
				Next();
			}
		}

		private void Next()
		{
			int currentSpectatingIndex = GetCurrentSpectatingIndex();
			currentSpectatingIndex++;
			if (currentSpectatingIndex >= _players.Count)
			{
				currentSpectatingIndex = 0;
			}
			CurrentSpectatingClient = _players[currentSpectatingIndex];
		}

		private void Previous()
		{
			int currentSpectatingIndex = GetCurrentSpectatingIndex();
			currentSpectatingIndex--;
			if (currentSpectatingIndex < 0)
			{
				currentSpectatingIndex = _players.Count - 1;
			}
			CurrentSpectatingClient = _players[currentSpectatingIndex];
		}

		private void CachePlayers()
		{
			_players.Clear();
			Lobby currentLobby = _clientController.ClientLobbyManager.CurrentLobby;
			LobbyPlayer val = null;
			if (currentLobby != null)
			{
				val = currentLobby.LobbyState.Players[_clientController.LocalID];
			}
			foreach (KeyValuePair<ushort, MPPlayer> player in _clientController.Players)
			{
				if ((Object)(object)player.Value.Player == (Object)null || player.Value.ShouldIgnore())
				{
					continue;
				}
				if (currentLobby != null && currentLobby.InGame && currentLobby.CurrentGamemode != null)
				{
					if (!currentLobby.LobbyState.Players.TryGetValue(player.Key, out var value))
					{
						continue;
					}
					if (currentLobby.CurrentGamemode is PropHunt)
					{
						if (value.Team != 0)
						{
							continue;
						}
					}
					else if (currentLobby.CurrentGamemode.TeamBased && value.Team != val.Team)
					{
						continue;
					}
				}
				_players.Add(player.Key);
			}
			if (_players.Count <= 0)
			{
				_players.Add(_clientController.LocalID);
			}
		}

		private int GetCurrentSpectatingIndex()
		{
			for (int i = 0; i < _players.Count; i++)
			{
				if (_players[i] == CurrentSpectatingClient)
				{
					return i;
				}
			}
			return 0;
		}

		public void EndSpectating()
		{
			ChatUI instance = ChatUI.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.SetState(ChatUI.States.Unfocused);
			}
			SpectatorUI.Instance.Deactivate();
			if ((Object)(object)_currentSpectatingPlayer != (Object)null)
			{
				_currentSpectatingPlayer.cam = null;
			}
			((Component)_uiManager.gameplay).gameObject.SetActive(true);
			_gameInput.DisableAllControllerMaps(0);
			_gameInput.EnableControllerMaps(BaseModule.IN_GAME_INPUT_MAPS, 0);
			if ((Object)(object)Instance != (Object)null)
			{
				_gameInput.EnableControllerMaps(BaseModule.MENU_INPUT_MAPS, 0);
			}
			Player currentPlayer = _worldHandler.GetCurrentPlayer();
			currentPlayer.userInputEnabled = true;
			currentPlayer.cam = _gameplayCamera;
			currentPlayer.SetIgnoreCamInput(false);
			currentPlayer.motor._rigidbody.isKinematic = false;
			_gameplayCamera.SetPlayerToFollow(currentPlayer);
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		public static void StartSpectating(bool forced)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!WorldHandler.instance.GetCurrentPlayer().userInputEnabled)
			{
				return;
			}
			if ((Object)(object)Instance != (Object)null)
			{
				if (forced)
				{
					Instance.Forced = true;
				}
			}
			else
			{
				Instance = new GameObject("Spectator Controller").AddComponent<SpectatorController>();
				Instance.Forced = forced;
			}
		}
	}
	public class SpectatorUI : MonoBehaviour
	{
		internal static SpectatorUI Instance;

		private TextMeshProUGUI _nextLabel;

		private TextMeshProUGUI _previousLabel;

		private TextMeshProUGUI _backLabel;

		private TextMeshProUGUI _tpLabel;

		private TextMeshProUGUI _tpGlyph;

		private TextMeshProUGUI _idLabel;

		private TextMeshProUGUI _backGlyph;

		private void Update()
		{
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			AuthUser localUser = instance.GetLocalUser();
			SpectatorController instance2 = SpectatorController.Instance;
			if (localUser != null && localUser.IsModerator)
			{
				((Component)_idLabel).gameObject.SetActive(true);
				int num = 0;
				if ((Object)(object)instance2 != (Object)null)
				{
					num = instance2.CurrentSpectatingClient;
				}
				((TMP_Text)_idLabel).text = $"Player ID: {num}";
			}
			else
			{
				((Component)_idLabel).gameObject.SetActive(false);
			}
			if (instance2.CanTeleportToCurrentPlayer())
			{
				((Component)_tpLabel).gameObject.SetActive(true);
				((Component)_tpGlyph).gameObject.SetActive(true);
			}
			else
			{
				((Component)_tpLabel).gameObject.SetActive(false);
				((Component)_tpGlyph).gameObject.SetActive(false);
			}
			if (instance2.Forced)
			{
				((Component)_backLabel).gameObject.SetActive(false);
				((Component)_backGlyph).gameObject.SetActive(false);
			}
			else
			{
				((Component)_backLabel).gameObject.SetActive(true);
				((Component)_backGlyph).gameObject.SetActive(true);
			}
		}

		private static TextMeshProUGUI MakeLabel(TextMeshProUGUI reference, string name)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			TMP_FontAsset font = ((TMP_Text)reference).font;
			float fontSize = ((TMP_Text)reference).fontSize;
			Material fontMaterial = ((TMP_Text)reference).fontMaterial;
			TextMeshProUGUI obj = new GameObject(name).AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj).font = font;
			((TMP_Text)obj).fontSize = fontSize;
			((TMP_Text)obj).fontMaterial = fontMaterial;
			((TMP_Text)obj).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)obj).fontStyle = (FontStyles)1;
			((TMP_Text)obj).outlineWidth = 0.2f;
			return obj;
		}

		private static TextMeshProUGUI MakeGlyph(TextMeshProUGUI reference, int actionID)
		{
			TextMeshProUGUI val = MakeLabel(reference, "");
			((Component)val).gameObject.SetActive(false);
			UIButtonGlyphComponent obj = ((Component)val).gameObject.AddComponent<UIButtonGlyphComponent>();
			obj.inputActionID = actionID;
			obj.localizedGlyphTextComponent = val;
			obj.localizedTextComponent = val;
			((Behaviour)obj).enabled = true;
			((Component)val).gameObject.SetActive(true);
			return val;
		}

		internal static void InitializeUI(GameplayUI gameplayUI)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Instance != (Object)null))
			{
				Instance = new GameObject("Spectator UI Root").AddComponent<SpectatorUI>();
				((Component)Instance).transform.SetParent((Transform)(object)((Component)((Component)gameplayUI).transform.parent).GetComponent<RectTransform>(), false);
				Instance.Init();
				Instance.Deactivate();
			}
		}

		private void Init()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: 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_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_0495: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0515: 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_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0603: Unknown result type (might be due to invalid IL or missing references)
			//IL_0626: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = ((Component)Instance).gameObject.AddComponent<RectTransform>();
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			TextMeshProUGUI[] componentsInChildren = ((Component)Core.Instance.UIManager.danceAbilityUI).GetComponentsInChildren<TextMeshProUGUI>(true);
			TextMeshProUGUI val2 = null;
			TextMeshProUGUI[] array = componentsInChildren;
			foreach (TextMeshProUGUI val3 in array)
			{
				if (((Object)((Component)((TMP_Text)val3).transform).gameObject).name == "DanceSelectConfirmText")
				{
					val2 = val3;
				}
			}
			if (!((Object)(object)val2 == (Object)null))
			{
				float num = 100f;
				float num2 = -50f;
				float num3 = 50f;
				float num4 = 75f;
				_previousLabel = MakeLabel(val2, "PreviousPlayer");
				((TMP_Text)_previousLabel).text = "Previous Player";
				((TMP_Text)_previousLabel).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_previousLabel).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_previousLabel).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_previousLabel).rectTransform.anchoredPosition = new Vector2(num + num4, num3 + num2);
				((Transform)((TMP_Text)_previousLabel).rectTransform).SetParent((Transform)(object)val, false);
				TextMeshProUGUI obj = MakeGlyph(val2, 57);
				((TMP_Text)obj).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)obj).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)obj).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)obj).rectTransform.anchoredPosition = new Vector2(num, num3 + num2);
				((Transform)((TMP_Text)obj).rectTransform).SetParent((Transform)(object)val, false);
				_nextLabel = MakeLabel(val2, "NextPlayer");
				((TMP_Text)_nextLabel).text = "Next Player";
				((TMP_Text)_nextLabel).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_nextLabel).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_nextLabel).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_nextLabel).rectTransform.anchoredPosition = new Vector2(num + num4, num3 + num2 * 2f);
				((Transform)((TMP_Text)_nextLabel).rectTransform).SetParent((Transform)(object)val, false);
				TextMeshProUGUI obj2 = MakeGlyph(val2, 29);
				((TMP_Text)obj2).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)obj2).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)obj2).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)obj2).rectTransform.anchoredPosition = new Vector2(num, num3 + num2 * 2f);
				((Transform)((TMP_Text)obj2).rectTransform).SetParent((Transform)(object)val, false);
				_backLabel = MakeLabel(val2, "BackLabel");
				((TMP_Text)_backLabel).text = "Back";
				((TMP_Text)_backLabel).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_backLabel).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_backLabel).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_backLabel).rectTransform.anchoredPosition = new Vector2(num + num4, num3 + num2 * 3f);
				((Transform)((TMP_Text)_backLabel).rectTransform).SetParent((Transform)(object)val, false);
				_backGlyph = MakeGlyph(val2, 3);
				((TMP_Text)_backGlyph).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_backGlyph).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_backGlyph).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_backGlyph).rectTransform.anchoredPosition = new Vector2(num, num3 + num2 * 3f);
				((Transform)((TMP_Text)_backGlyph).rectTransform).SetParent((Transform)(object)val, false);
				_tpLabel = MakeLabel(val2, "TPLabel");
				((TMP_Text)_tpLabel).text = "Teleport to Player";
				((TMP_Text)_tpLabel).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_tpLabel).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_tpLabel).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_tpLabel).rectTransform.anchoredPosition = new Vector2(num + num4, num3 + num2 * 4f);
				((Transform)((TMP_Text)_tpLabel).rectTransform).SetParent((Transform)(object)val, false);
				_tpGlyph = MakeGlyph(val2, 2);
				((TMP_Text)_tpGlyph).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_tpGlyph).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_tpGlyph).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_tpGlyph).rectTransform.anchoredPosition = new Vector2(num, num3 + num2 * 4f);
				((Transform)((TMP_Text)_tpGlyph).rectTransform).SetParent((Transform)(object)val, false);
				_idLabel = MakeLabel(val2, "IdLabel");
				((TMP_Text)_idLabel).text = "Player ID";
				((TMP_Text)_idLabel).rectTransform.anchorMin = new Vector2(0f, 0f);
				((TMP_Text)_idLabel).rectTransform.anchorMax = new Vector2(1f, 1f);
				((TMP_Text)_idLabel).rectTransform.pivot = new Vector2(0f, 1f);
				((TMP_Text)_idLabel).rectTransform.anchoredPosition = new Vector2(num + num4, num3 + num2 * 5f);
				((Transform)((TMP_Text)_idLabel).rectTransform).SetParent((Transform)(object)val, false);
			}
		}

		public void Activate()
		{
			((Component)this).gameObject.SetActive(true);
		}

		public void Deactivate()
		{
			((Component)this).gameObject.SetActive(false);
		}

		internal static void DestroyUI()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)Instance);
			}
			Instance = null;
		}
	}
	public class StatsUI : MonoBehaviour
	{
		public bool Displaying;

		private GameObject _canvas;

		private TextMeshProUGUI _statsLabel;

		private const string TokenPrefix = "$";

		private const float MinHeight = -1100f;

		private const float MaxHeight = 2945f;

		private const float AutoScrollSpeed = 60f;

		private const float ManualScrollSpeed = 400f;

		private const float AutoScrollTime = 3f;

		private const int UpDownAxis = 1;

		private const int UpButton = 21;

		private const int DownButton = 56;

		private const int CloseButton = 3;

		private const string Music = "MusicTrack_InThePocket";

		private float _autoScrollTimer;

		private string _originalText;

		private bool _wasMusicPlaying;

		private AudioSource _musicAudioSource;

		public static StatsUI Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			_canvas = ((Component)((Component)this).transform.Find("Canvas")).gameObject;
			_musicAudioSource = ((Component)((Component)this).transform.Find("Stats Music")).GetComponent<AudioSource>();
			_musicAudioSource.outputAudioMixerGroup = Core.Instance.AudioManager.mixerGroups[4];
			_musicAudioSource.clip = Core.Instance.Assets.LoadAssetFromBundle<MusicTrack>("coreassets", "MusicTrack_InThePocket").AudioClip;
			_statsLabel = ((Component)_canvas.transform.Find("Stats")).GetComponent<TextMeshProUGUI>();
			((TMP_Text)_statsLabel).spriteAsset = MPAssets.Instance.Sprites;
			_originalText = ((TMP_Text)_statsLabel).text;
			UIUtility.MakeGlyph(((Component)_canvas.transform.Find("Controls").Find("Close Glyph")).GetComponent<TextMeshProUGUI>(), 3);
			_canvas.SetActive(false);
		}

		private void Update()
		{
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (Displaying)
			{
				if (_autoScrollTimer <= 0f)
				{
					RectTransform rectTransform = ((TMP_Text)_statsLabel).rectTransform;
					((Transform)rectTransform).localPosition = ((Transform)rectTransform).localPosition + new Vector3(0f, 60f * Core.dt, 0f);
				}
				GameInput gameInput = Core.Instance.GameInput;
				float axis = gameInput.GetAxis(1, 0);
				bool flag = axis > 0f;
				bool flag2 = axis < 0f;
				bool buttonNew = gameInput.GetButtonNew(3, 0);
				if (flag || flag2)
				{
					_autoScrollTimer = 3f;
				}
				if (flag2)
				{
					RectTransform rectTransform2 = ((TMP_Text)_statsLabel).rectTransform;
					((Transform)rectTransform2).localPosition = ((Transform)rectTransform2).localPosition + new Vector3(0f, 400f * Core.dt, 0f);
				}
				if (flag)
				{
					RectTransform rectTransform3 = ((TMP_Text)_statsLabel).rectTransform;
					((Transform)rectTransform3).localPosition = ((Transform)rectTransform3).localPosition - new Vector3(0f, 400f * Core.dt, 0f);
				}
				if (buttonNew)
				{
					Deactivate();
				}
				_autoScrollTimer -= Core.dt;
				if (_autoScrollTimer < 0f)
				{
					_autoScrollTimer = 0f;
				}
			}
			float y = ((TMP_Text)_statsLabel).rectTransform.anchoredPosition.y;
			y = Mathf.Clamp(y, -1100f, 2945f);
			((TMP_Text)_statsLabel).rectTransform.anchoredPosition = new Vector2(0f, y);
		}

		public void Activate()
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if (MPSettings.Instance.StatsScreenMusic)
			{
				if (NetRadioSupport.Installed)
				{
					NetRadioSupport.Paused = true;
				}
				IMusicPlayer musicPlayer = Core.Instance.AudioManager.MusicPlayer;
				_wasMusicPlaying = musicPlayer.IsPlaying;
				musicPlayer.Pause();
				_musicAudioSource.Play();
			}
			MPUtility.CloseMenusAndSpectator();
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			currentPlayer.ui.TurnOn(false);
			currentPlayer.phone.AllowPhone(false, false, false);
			Displaying = true;
			_canvas.SetActive(true);
			InitializeStats();
			((TMP_Text)_statsLabel).rectTransform.anchoredPosition = new Vector2(0f, -1100f);
			_autoScrollTimer = 0f;
			GameInput gameInput = Core.Instance.GameInput;
			gameInput.DisableAllControllerMaps(0);
			gameInput.EnableControllerMaps(BaseModule.MENU_INPUT_MAPS, 0);
			currentPlayer.userInputEnabled = false;
		}

		public void Deactivate()
		{
			if (MPSettings.Instance.StatsScreenMusic)
			{
				if (NetRadioSupport.Installed)
				{
					NetRadioSupport.Paused = false;
				}
				_musicAudioSource.Stop();
				IMusicPlayer musicPlayer = Core.Instance.AudioManager.MusicPlayer;
				if (_wasMusicPlaying)
				{
					musicPlayer.Play();
				}
			}
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			currentPlayer.userInputEnabled = true;
			currentPlayer.ui.TurnOn(true);
			currentPlayer.phone.AllowPhone(true, false, false);
			Displaying = false;
			_canvas.SetActive(false);
			GameInput gameInput = Core.Instance.GameInput;
			gameInput.DisableAllControllerMaps(0);
			gameInput.EnableControllerMaps(BaseModule.IN_GAME_INPUT_MAPS, 0);
			if ((Object)(object)SpectatorController.Instance != (Object)null)
			{
				gameInput.EnableControllerMaps(BaseModule.MENU_INPUT_MAPS, 0);
			}
		}

		private void ReplaceStatToken(string statToken, string text)
		{
			ReplaceToken(statToken, "<color=yellow>" + text + "</color>");
		}

		private void ReplaceToken(string token, string text)
		{
			((TMP_Text)_statsLabel).text = ((TMP_Text)_statsLabel).text.Replace("$" + token, text);
		}

		private void InitializeStats()
		{
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: 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_017f: Expected I4, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Expected I4, but got Unknown
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected I4, but got Unknown
			((TMP_Text)_statsLabel).text = _originalText;
			MPStats stats = MPSaveData.Instance.Stats;
			string playerDisplayName = MPUtility.GetPlayerDisplayName(MPSettings.Instance.PlayerName);
			ReplaceToken("s_name", playerDisplayName);
			ReplaceStatToken("s_elitesbeaten", stats.ElitesBeaten.ToString());
			ReplaceStatToken("s_elites", stats.ElitesPlayedAgainst.ToString());
			ReplaceStatToken("s_asleeptime", FormatSecondsToTime(stats.TimeSpentAsleep));
			ReplaceStatToken("s_asleep", stats.TimesFallenAsleep.ToString());
			ReplaceStatToken("s_spectating", FormatSecondsToTime(stats.TimeSpentSpectating));
			ReplaceStatToken("s_playershit", stats.PlayersHit.ToString());
			ReplaceStatToken("s_timeshit", stats.TimesHit.ToString());
			ReplaceStatToken("s_deaths", stats.Deaths.ToString());
			ReplaceStatToken("s_hello", stats.TimesSaidHello.ToString());
			Array values = Enum.GetValues(typeof(GamemodeIDs));
			for (int num = values.Length - 1; num >= 0; num--)
			{
				GamemodeIDs val = (GamemodeIDs)values.GetValue(num);
				uint num2 = 0u;
				uint num3 = 0u;
				uint num4 = 0u;
				if (stats.GamemodesPlayed.TryGetValue(val, out var value))
				{
					num2 = value;
				}
				if (stats.GamemodesPlayedAlone.TryGetValue(val, out value))
				{
					num3 = value;
				}
				if (stats.GamemodesWon.TryGetValue(val, out value))
				{
					num4 = value;
				}
				ReplaceStatToken($"s_played{(int)val}", num2.ToString());
				ReplaceStatToken($"s_alone{(int)val}", num3.ToString());
				ReplaceStatToken($"s_won{(int)val}", num4.ToString());
			}
		}

		private static string FormatSecondsToTime(double totalSeconds)
		{
			int num = (int)(totalSeconds / 3600.0);
			int num2 = (int)(totalSeconds % 3600.0 / 60.0);
			int num3 = (int)(totalSeconds % 60.0);
			return $"{num:D2}:{num2:D2}:{num3:D2}";
		}

		public static void Create()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			GameObject obj = Object.Instantiate<GameObject>(MPAssets.Instance.Bundle.LoadAsset<GameObject>("Stats UI"));
			obj.transform.SetParent(((Component)Core.Instance.UIManager).transform, false);
			obj.AddComponent<StatsUI>();
		}
	}
	public class StreamedCharacterInstance
	{
		public int Outfit;

		private CharacterVisual _visual;

		private object _charDef;

		public CharacterHandle Handle { get; private set; }

		public StreamedCharacterInstance(CharacterHandle handle)
		{
			Handle = handle;
			Handle.AddReference();
		}

		public void SetVisual(CharacterVisual visual)
		{
			_visual = visual;
			_charDef = ((Component)visual).GetComponentInChildren(CrewBoomTypes.CharacterDefinitionType);
		}

		public void ApplyOutfit(int outfitIndex)
		{
			Outfit = outfitIndex;
			object obj = (CrewBoomTypes.CharacterDefinitionOutfitsField.GetValue(_charDef) as object[])[outfitIndex];
			object[] array = CrewBoomTypes.CharacterOutfitMaterialContainersField.GetValue(obj) as object[];
			SkinnedMeshRenderer[] array2 = CrewBoomTypes.CharacterDefinitionRenderersField.GetValue(_charDef) as SkinnedMeshRenderer[];
			SkinnedMeshRenderer val = null;
			for (int i = 0; i < array2.Length; i++)
			{
				SkinnedMeshRenderer val2 = array2[i];
				bool flag = (CrewBoomTypes.CharacterOutfitEnabledRenderersField.GetValue(obj) as bool[])[i];
				((Component)val2).gameObject.SetActive(flag);
				if (!flag)
				{
					continue;
				}
				if ((Object)(object)val == (Object)null)
				{
					val = val2;
				}
				Material[] array3 = CrewBoomTypes.CharacterOutfitRendererMaterialsField.GetValue(array[i]) as Material[];
				bool[] array4 = CrewBoomTypes.CharacterOutfitRendererUseShaderForMaterialField.GetValue(array[i]) as bool[];
				for (int j = 0; j < array3.Length; j++)
				{
					if (array4[j])
					{
						array3[j].shader = CrewBoomStreamer.CharacterShader;
					}
				}
				((Renderer)val2).sharedMaterials = array3;
			}
			_visual.mainRenderer = val;
			_visual.canBlink = (bool)CrewBoomTypes.CharacterDefinitionCanBlinkField.GetValue(_charDef);
		}
	}
	public class StyleSwitchMenuEx : MonoBehaviour
	{
		public Material[] OriginalMaterials;

		public static StyleSwitchMenuEx Get(StyleSwitchMenu menu)
		{
			StyleSwitchMenuEx styleSwitchMenuEx = ((Component)menu).GetComponent<StyleSwitchMenuEx>();
			if ((Object)(object)styleSwitchMenuEx == (Object)null)
			{
				styleSwitchMenuEx = ((Component)menu).gameObject.AddComponent<StyleSwitchMenuEx>();
			}
			return styleSwitchMenuEx;
		}
	}
	public class SystemGuid
	{
		private static string _systemGuid = string.Empty;

		public static string Value()
		{
			if (string.IsNullOrEmpty(_systemGuid))
			{
				_systemGuid = GetHash(SystemInfo.deviceUniqueIdentifier + SystemInfo.processorType + SystemInfo.graphicsDeviceName + SystemInfo.operatingSystem);
			}
			return _systemGuid;
		}

		private static string GetHash(string s)
		{
			try
			{
				return new Guid(new MD5CryptoServiceProvider().ComputeHash(Encoding.UTF8.GetBytes(s))).ToString().ToUpper();
			}
			catch (Exception ex)
			{
				return ex.Message;
			}
		}
	}
	public static class SystemNumericsExtensions
	{
		public static Vector3 ToUnityVector3(this Vector3 vector)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(vector.X, vector.Y, vector.Z);
		}

		public static Vector3 ToSystemVector3(this Vector3 vector)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(vector.x, vector.y, vector.z);
		}

		public static Quaternion ToUnityQuaternion(this Quaternion quaternion)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Quaternion(quaternion.X, quaternion.Y, quaternion.Z, quaternion.W);
		}

		public static Quaternion ToSystemQuaternion(this Quaternion quaternion)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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)
			return new Quaternion(quaternion.x, quaternion.y, quaternion.z, quaternion.w);
		}
	}
	public static class TagUtils
	{
		public static GraffitiArt GetRandomGraffitiArt(GraffitiSpot spot, Player player)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if ((int)spot.size == 0)
			{
				return spot.GraffitiArtInfo.FindByCharacter(player.character);
			}
			List<GraffitiArt> list = spot.GraffitiArtInfo.graffitiArt.Where((GraffitiArt art) => art.graffitiSize == spot.size).ToList();
			return list[Random.Range(0, list.Count)];
		}
	}
	public class Team
	{
		public string Name;

		public Color Color;

		public Team(string name, Color color)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Name = name;
			Color = color;
		}
	}
	public class TemporaryMapPin : MonoBehaviour
	{
		private float _timer = float.PositiveInfinity;

		private MapPin _pin;

		private void Update()
		{
			if ((Object)(object)_pin.m_ObjectiveObject == (Object)null)
			{
				Remove();
			}
			_pin.SetLocation();
			_timer -= Time.deltaTime;
			if (_timer <= 0f)
			{
				Remove();
			}
		}

		private void Remove()
		{
			Mapcontroller.Instance.m_MapPins.Remove(_pin);
			_pin.isMapPinValid = false;
			_pin.DisableMapPinGameObject();
			Object.Destroy((Object)(object)((Component)_pin).gameObject);
		}

		public void Initialize(float timer, MapPin pin)
		{
			_timer = timer;
			_pin = pin;
		}
	}
	public class TimerUI : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DeactivateCoroutine>d__10 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public TimerUI <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DeactivateCoroutine>d__10(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				TimerUI timerUI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					timerUI.Deactivate();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private GameObject _canvas;

		private TextMeshProUGUI _label;

		public static TimerUI Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			_canvas = ((Component)((Component)this).transform.Find("Canvas")).gameObject;
			_label = ((Component)_canvas.transform.Find("Timer")).GetComponent<TextMeshProUGUI>();
			Deactivate();
		}

		public void Activate()
		{
			((MonoBehaviour)this).StopAllCoroutines();
			_canvas.SetActive(true);
		}

		public void Deactivate()
		{
			((MonoBehaviour)this).StopAllCoroutines();
			_canvas.SetActive(false);
		}

		public void DeactivateDelayed()
		{
			((MonoBehaviour)this).StartCoroutine(DeactivateCoroutine());
		}

		[IteratorStateMachine(typeof(<DeactivateCoroutine>d__10))]
		private IEnumerator DeactivateCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DeactivateCoroutine>d__10(0)
			{
				<>4__this = this
			};
		}

		public static string GetTimeString(float time)
		{
			string text = time.ToString(CultureInfo.CurrentCulture);
			int num = ((int)time).ToString().Length + 3;
			if (text.Length > num)
			{
				text = text.Remove(num);
			}
			if ((double)time == 0.0)
			{
				text = "0.00";
			}
			return text;
		}

		public void SetTime(float time)
		{
			SetText(GetTimeString(time));
		}

		public void SetText(string text)
		{
			((TMP_Text)_label).text = text;
		}

		public static void Create()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			GameObject obj = Object.Instantiate<GameObject>(MPAssets.Instance.Bundle.LoadAsset<GameObject>("Timer UI"));
			obj.transform.SetParent(((Component)Core.Instance.UIManager).transform, false);
			obj.AddComponent<TimerUI>();
		}
	}
	public class UIScreenIndicators : MonoBehaviour
	{
		private float _minDistance = 5f;

		private float _maxDistance = 20f;

		private float _distanceSizeMultiplier = 0.5f;

		private Vector2 _originalSize;

		private UIManager _uiManager;

		private GameObject _indicator;

		private Transform _canvasTf;

		private Dictionary<Transform, RectTransform> _indicators = new Dictionary<Transform, RectTransform>();

		private bool _visible = true;

		private void Awake()
		{
			//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)
			_uiManager = Core.Instance.UIManager;
			_canvasTf = ((Component)this).transform.Find("Canvas");
			_indicator = ((Component)_canvasTf.Find("Indicator")).gameObject;
			_originalSize = GameObjectExtensions.RectTransform(_indicator).sizeDelta;
			_indicator.SetActive(false);
		}

		private void LateUpdate()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: 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_013c: 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_0152: Unknown result type (might be due to invalid IL or missing references)
			if (!((Component)_uiManager.gameplay.gameplayScreen).gameObject.activeInHierarchy)
			{
				((Component)_canvasTf).gameObject.SetActive(false);
				return;
			}
			((Component)_canvasTf).gameObject.SetActive(true);
			Camera cam = GameplayCamera.instance.cam;
			foreach (KeyValuePair<Transform, RectTransform> indicator in _indicators)
			{
				Transform key = indicator.Key;
				RectTransform value = indicator.Value;
				if (!IsInFront(((Component)cam).transform.position, ((Component)cam).transform.forward, indicator.Key.position))
				{
					((Component)value).gameObject.SetActive(false);
					continue;
				}
				((Component)value).gameObject.SetActive(true);
				Vector3 val = cam.WorldToViewportPoint(key.position);
				value.anchorMax = Vector2.op_Implicit(val);
				value.anchorMin = Vector2.op_Implicit(val);
				float num = Vector3.Distance(((Component)cam).transform.position, key.position);
				num -= _minDistance;
				num /= _maxDistance;
				num = Mathf.Clamp(num, 0f, 1f);
				value.sizeDelta = Vector2.Lerp(_originalSize, _originalSize * _distanceSizeMultiplier * Theme.CurrentTheme.RaceReticleSize, num);
			}
		}

		private bool IsInFront(Vector3 cameraPos, Vector3 cameraForward, Vector3 targetPos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = targetPos - cameraPos;
			return Vector3.Dot(cameraForward, val) > 0f;
		}

		public void AddIndicator(Transform target)
		{
			GameObject val = Object.Instantiate<GameObject>(_indicator.gameObject);
			val.transform.SetParent(_canvasTf, false);
			val.gameObject.SetActive(true);
			_indicators[target] = GameObjectExtensions.RectTransform(val);
		}

		public void RemoveIndicator(Transform target)
		{
			if (_indicators.TryGetValue(target, out var value))
			{
				_indicators.Remove(target);
				Object.Destroy((Object)(object)((Component)value).gameObject);
			}
		}

		public static UIScreenIndicators Create()
		{
			GameObject obj = Object.Instantiate<GameObject>(MPAssets.Instance.Bundle.LoadAsset<GameObject>("Screen Indicators UI"));
			obj.transform.SetParent(((Component)Core.Instance.UIManager).transform, false);
			return obj.AddComponent<UIScreenIndicators>();
		}
	}
	public static class UIUtility
	{
		private static bool _initialized;

		private static TextMeshProUGUI _referenceLabel;

		public static void Initialize()
		{
			_initialized = true;
			TextMeshProUGUI[] componentsInChildren = ((Component)Core.Instance.UIManager.danceAbilityUI).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if (((Object)((Component)((TMP_Text)val).transform).gameObject).name == "DanceSelectConfirmText")
				{
					_referenceLabel = val;
					break;
				}
			}
		}

		public static void MakeGlyph(TextMeshProUGUI text, int actionID)
		{
			if (!_initialized)
			{
				Initialize();
			}
			((Component)text).gameObject.SetActive(false);
			((TMP_Text)text).font = ((TMP_Text)_referenceLabel).font;
			((TMP_Text)text).fontMaterial = ((TMP_Text)_referenceLabel).fontMaterial;
			UIButtonGlyphComponent obj = ((Component)text).gameObject.AddComponent<UIButtonGlyphComponent>();
			obj.inputActionID = actionID;
			obj.localizedGlyphTextComponent = text;
			obj.localizedTextComponent = text;
			((Behaviour)obj).enabled = true;
			((Component)text).gameObject.SetActive(true);
		}
	}
	public class XHairUI : MonoBehaviour
	{
		public enum Modes
		{
			Off,
			On,
			Cross
		}

		public Modes CurrentMode;

		public float HitMarkerTime;

		private GameObject _xhair;

		private GameObject _cross;

		private GameObject _hitMarker;

		public static XHairUI Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			Transform val = ((Component)this).transform.Find("Canvas");
			_xhair = ((Component)val.Find("xhair")).gameObject;
			_cross = ((Component)val.Find("cross")).gameObject;
			_hitMarker = ((Component)val.Find("hitmarker")).gameObject;
			UpdateSprites();
		}

		private void Update()
		{
			UpdateSprites();
			HitMarkerTime -= Time.deltaTime;
		}

		private void UpdateSprites()
		{
			if (HitMarkerTime > 0f)
			{
				_hitMarker.SetActive(true);
			}
			else
			{
				_hitMarker.SetActive(false);
			}
			_xhair.SetActive(false);
			_cross.SetActive(false);
			switch (CurrentMode)
			{
			case Modes.On:
				_xhair.SetActive(true);
				break;
			case Modes.Cross:
				_cross.SetActive(true);
				break;
			}
		}

		public static XHairUI Create()
		{
			GameObject obj = Object.Instantiate<GameObject>(MPAssets.Instance.Bundle.LoadAsset<GameObject>("XHair UI"));
			obj.transform.SetParent(((Component)Core.Instance.UIManager).transform, false);
			return obj.AddComponent<XHairUI>();
		}
	}
	public class XmasController : MonoBehaviour
	{
		private MPAssets _mpAssets;

		public static XmasController Instance { get; private set; }

		private void Awake()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			_mpAssets = MPAssets.Instance;
			Scene scene = ((Component)this).gameObject.scene;
			if (((Scene)(ref scene)).name == "hideout")
			{
				DoHideoutAwake();
			}
		}

		private void Start()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Scene scene = ((Component)this).gameObject.scene;
			if (((Scene)(ref scene)).name == "hideout")
			{
				DoHideoutStart();
			}
		}

		private void DoHideoutStart()
		{
			LightmapSettings.lightmaps = (LightmapData[])(object)new LightmapData[0];
			QualitySettings.shadowDistance = 150f;
			RenderSettings.skybox.mainTexture = (Texture)(object)_mpAssets.XmasSky;
		}

		private void DoHideoutAwake()
		{
			Transform val = Object.Instantiate<GameObject>(_mpAssets.XmasHideoutPrefab).transform.Find("Chunk");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			StageChunk[] array = Object.FindObjectsOfType<StageChunk>();
			StageChunk val2 = null;
			StageChunk[] array2 = array;
			foreach (StageChunk val3 in array2)
			{
				if (((Object)val3).name == "Hideout_Props")
				{
					val2 = val3;
					break;
				}
			}
			if (!((Object)(object)val2 == (Object)null))
			{
				((Component)val).transform.SetParent(((Component)val2).transform, true);
			}
		}

		public static void Create()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new GameObject("Xmas Controller").AddComponent<XmasController>();
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "BombRushMP.Plugin";

		public const string PLUGIN_NAME = "BombRushMP.Plugin";

		public const string PLUGIN_VERSION = "1.0.1";
	}
}
namespace BombRushMP.Plugin.Phone
{
	[HarmonyPatch(typeof(AnimationEventRelay))]
	internal static class AnimationEventRelayPatch
	{
		[HarmonyPatch("ActivateLeftLegCollider")]
		[HarmonyPatch("ActivateRightLegCollider")]
		[HarmonyPatch("ActivateUpperBodyCollider")]
		[HarmonyPatch("DeactivateLeftLegCollider")]
		[HarmonyPatch("DeactivateRightLegCollider")]
		[HarmonyPatch("DeactivateUpperBodyCollider")]
		private static bool ActivateCollider(AnimationEventRelay __instance)
		{
			if (MPUtility.IsMultiplayerPlayer(__instance.player))
			{
				return false;
			}
			return true;
		}
	}
	public class AppGamemodeSettings : CustomApp
	{
		private GamemodeIDs _currentGamemode = (GamemodeIDs)(-1);

		private Dictionary<int, SimplePhoneButton> _buttonBySettingID = new Dictionary<int, SimplePhoneButton>();

		public override bool Available => false;

		public static void Initialize()
		{
			PhoneAPI.RegisterApp<AppGamemodeSettings>("gamemode settings", (Sprite)null);
		}

		public override void OnAppInit()
		{
			((CustomApp)this).OnAppInit();
			((CustomApp)this).CreateIconlessTitleBar("Gamemode Settings", 80f);
			base.ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
		}

		public override void OnAppEnable()
		{
			((App)this).OnAppEnable();
			UpdateGamemode();
		}

		public override void OnAppUpdate()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			((App)this).OnAppUpdate();
			if (GetCurrentGamemode() != _currentGamemode)
			{
				UpdateGamemode();
			}
			UpdateLabels();
		}

		private void UpdateGamemode()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			_currentGamemode = GetCurrentGamemode();
			_buttonBySettingID.Clear();
			base.ScrollView.RemoveAllButtons();
			GamemodeSettings currentSettings = GetCurrentSettings();
			if (currentSettings == null)
			{
				_currentGamemode = (GamemodeIDs)(-1);
			}
			SimplePhoneButton val = PhoneUIUtility.CreateSimpleButton("Reset");
			((PhoneButton)val).OnConfirm = (Action)Delegate.Combine(((PhoneButton)val).OnConfirm, (Action)delegate
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				GamemodeSettings gamemodeSettings = (currentSettings = GetDefaultSettings());
				MPSaveData.Instance.GamemodeSettings[_currentGamemode] = gamemodeSettings.ToSaved();
				Core.Instance.SaveManager.SaveCurrentSaveSlot();
				SendSettings(gamemodeSettings);
				UpdateLabels();
			});
			base.ScrollView.AddButton((PhoneButton)(object)val);
			foreach (KeyValuePair<int, GamemodeSetting> setting in currentSettings.SettingByID)
			{
				SimplePhoneButton val2 = PhoneUIUtility.CreateSimpleButton(setting.Value.ToString());
				_buttonBySettingID[setting.Key] = val2;
				((PhoneButton)val2).OnConfirm = (Action)Delegate.Combine(((PhoneButton)val2).OnConfirm, (Action)delegate
				{
					//IL_005f: Unknown result type (might be due to invalid IL or missing references)
					GamemodeSettings currentSettings2 = GetCurrentSettings();
					GamemodeSetting gamemodeSetting = currentSettings2.SettingByID[setting.Key];
					if (gamemodeSetting.OnCheckVisibility == null || gamemodeSetting.OnCheckVisibility(currentSettings2.SettingByID))
					{
						gamemodeSetting.Next();
						MPSaveData.Instance.GamemodeSettings[_currentGamemode] = currentSettings2.ToSaved();
						Core.Instance.SaveManager.SaveCurrentSaveSlot();
						SendSettings(currentSettings2);
						UpdateLabels();
					}
				});
				base.ScrollView.AddButton((PhoneButton)(object)val2);
			}
		}

		private void UpdateLabels()
		{
			GamemodeSettings currentSettings = GetCurrentSettings();
			foreach (KeyValuePair<int, GamemodeSetting> item in currentSettings.SettingByID)
			{
				if (_buttonBySettingID.TryGetValue(item.Key, out var value))
				{
					if (item.Value.OnCheckVisibility != null && !item.Value.OnCheckVisibility(currentSettings.SettingByID))
					{
						((TMP_Text)value.Label).text = "-";
					}
					else
					{
						((TMP_Text)value.Label).text = item.Value.ToString();
					}
				}
			}
		}

		private GamemodeIDs GetCurrentGamemode()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return (GamemodeIDs)(((??)ClientController.Instance.ClientLobbyManager.CurrentLobby?.LobbyState.Gamemode) ?? (-1));
		}

		private GamemodeSettings GetCurrentSettings()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Lobby currentLobby = ClientController.Instance.ClientLobbyManager.CurrentLobby;
			if (currentLobby == null)
			{
				return null;
			}
			return GamemodeFactory.ParseGamemodeSettings(GetCurrentGamemode(), currentLobby.LobbyState.GamemodeSettings);
		}

		private GamemodeSettings GetDefaultSettings()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (ClientController.Instance.ClientLobbyManager.CurrentLobby == null)
			{
				return null;
			}
			return GamemodeFactory.GetGamemodeSettings(GetCurrentGamemode());
		}

		private void SendSettings(GamemodeSettings settings)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			ClientController.Instance.ClientLobbyManager.SetGamemode(GetCurrentGamemode(), settings);
		}
	}
	public class AppMultiplayerAcceptInvite : CustomApp
	{
		private static uint LobbyId;

		private static Action OnAccept;

		private static Action OnDecline;

		public override bool Available => false;

		public static void Initialize()
		{
			PhoneAPI.RegisterApp<AppMultiplayerAcceptInvite>("accept invite", (Sprite)null);
		}

		public static void Show(uint lobbyId, Phone phone, Action onAccept = null, Action onDecline = null)
		{
			LobbyId = lobbyId;
			OnAccept = onAccept;
			OnDecline = onDecline;
			phone.OpenApp(typeof(AppMultiplayerAcceptInvite));
		}

		public override void OnAppInit()
		{
			((CustomApp)this).OnAppInit();
			((CustomApp)this).CreateIconlessTitleBar("Accept Invite?", 70f);
			base.ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
		}

		public override void OnAppEnable()
		{
			((App)this).OnAppEnable();
			PopulateButtons();
		}

		private void PopulateButtons()
		{
			base.ScrollView.RemoveAllButtons();
			SimplePhoneButton val = PhoneUIUtility.CreateSimpleButton("Yes");
			SimplePhoneButton obj = val;
			((PhoneButton)obj).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj).OnConfirm, (Action)delegate
			{
				Accept();
				((App)this).MyPhone.CloseCurrentApp();
				OnAccept?.Invoke();
				OnAccept = null;
				OnDecline = null;
			});
			base.ScrollView.AddButton((PhoneButton)(object)val);
			val = PhoneUIUtility.CreateSimpleButton("No");
			SimplePhoneButton obj2 = val;
			((PhoneButton)obj2).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj2).OnConfirm, (Action)delegate
			{
				Decline();
				((App)this).MyPhone.CloseCurrentApp();
				OnDecline?.Invoke();
				OnAccept = null;
				OnDecline = null;
			});
			base.ScrollView.AddButton((PhoneButton)(object)val);
		}

		private void Accept()
		{
			ClientController.Instance.ClientLobbyManager.JoinLobby(LobbyId);
			LobbyId = 0u;
		}

		private void Decline()
		{
			ClientController.Instance.ClientLobbyManager.DeclineInvite(LobbyId);
			LobbyId = 0u;
		}
	}
	public class AppMultiplayerBan : PlayerPickerApp
	{
		public override bool Available
		{
			get
			{
				ClientController instance = ClientController.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return false;
				}
				if (!instance.Connected)
				{
					return false;
				}
				AuthUser localUser = instance.GetLocalUser();
				if (localUser == null)
				{
					return false;
				}
				return localUser.IsModerator;
			}
		}

		public static void Initialize()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			byte[] array = File.ReadAllBytes(Path.Combine(MPSettings.Instance.Directory, "acn_icon.png"));
			Texture2D val = new Texture2D(1, 1);
			ImageConversion.LoadImage(val, array);
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Sprite val2 = TextureUtility.CreateSpriteFromTexture(val);
			PhoneAPI.RegisterApp<AppMultiplayerBan>("ban players", val2);
		}

		public override void OnAppInit()
		{
			base.OnAppInit();
			((CustomApp)this).CreateIconlessTitleBar("Ban", 80f);
			AllowEveryone = false;
		}

		public override void PlayerChosen(ushort[] playerIds)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			base.PlayerChosen(playerIds);
			_ = ClientController.Instance;
			foreach (ushort num in playerIds)
			{
				ClientController.Instance.SendPacket((Packet)new ClientChat($"/banid {num}"), (SendModes)2, (NetChannels)4);
			}
		}
	}
	public class AppMultiplayerCurrentLobby : CustomApp
	{
		private SimplePhoneButton _allowTeamSwitchingButton;

		private SimplePhoneButton _challengeModeButton;

		public override bool Available => false;

		public static void Initialize()
		{
			PhoneAPI.RegisterApp<AppMultiplayerCurrentLobby>("lobby", (Sprite)null);
		}

		public override void OnAppInit()
		{
			((CustomApp)this).OnAppInit();
			((CustomApp)this).CreateIconlessTitleBar("Lobby", 80f);
			base.ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
		}

		public override void OnAppEnable()
		{
			((App)this).OnAppEnable();
			RefreshApp();
		}

		public override void OnAppUpdate()
		{
			((App)this).OnAppUpdate();
			if (ClientController.Instance.ClientLobbyManager.CurrentLobby == null)
			{
				((App)this).MyPhone.CloseCurrentApp();
			}
			RefreshLabels();
		}

		private void RefreshLabels()
		{
			Lobby currentLobby = ClientController.Instance.ClientLobbyManager.CurrentLobby;
			if (currentLobby?.LobbyState != null)
			{
				if ((Object)(object)_allowTeamSwitchingButton != (Object)null)
				{
					((TMP_Text)_allowTeamSwitchingButton.Label).text = "Allow Team Switching = " + (currentLobby.LobbyState.AllowTeamSwitching ? "ON" : "OFF");
				}
				if ((Object)(object)_challengeModeButton != (Object)null)
				{
					((TMP_Text)_challengeModeButton.Label).text = "Public = " + (currentLobby.LobbyState.Challenge ? "ON" : "OFF");
				}
			}
		}

		private void RefreshApp()
		{
			base.ScrollView.RemoveAllButtons();
			ClientController clientController = ClientController.Instance;
			ClientLobbyManager lobbyManager = clientController.ClientLobbyManager;
			Lobby currentLobby = lobbyManager.CurrentLobby;
			if (currentLobby == null)
			{
				return;
			}
			currentLobby.GetOrCreateGamemode();
			PhoneButton val = null;
			if (currentLobby.LobbyState.HostId == clientController.LocalID)
			{
				if (!currentLobby.InGame)
				{
					val = (PhoneButton)(object)PhoneUIUtility.CreateSimpleButton("Start Game");
					PhoneButton obj = val;
					obj.OnConfirm = (Action)Delegate.Combine(obj.OnConfirm, (Action)delegate
					{
						if (!currentLobby.InGame)
						{
							lobbyManager.StartGame();
						}
					});
					base.ScrollView.AddButton(val);
					val = (PhoneButton)(object)PhoneUIUtility.CreateSimpleButton("Reset Wins");
					PhoneButton obj2 = val;
					obj2.OnConfirm = (Action)Delegate.Combine(obj2.OnConfirm, (Action)delegate
					{
						if (!currentLobby.InGame)
						{
							lobbyManager.ResetWins();
						}
					});
					base.ScrollView.AddButton(val);
					val = (PhoneButton)(object)PhoneUIUtility.CreateSimpleButton("Change Gamemode");
					PhoneButton obj3 = val;
					obj3.OnConfirm = (Action)Delegate.Combine(obj3.OnConfirm, (Action)delegate
					{
						//IL_001b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0021: Expected I4, but got Unknown
						Array values = Enum.GetValues(typeof(GamemodeIDs));
						int num = (int)currentLobby.LobbyState.Gamemode;
						num++;
						if (num == 6 && clientController.ServerState.Tags.Contains("phlocked"))
						{
							num++;
						}
						if (num >= values.Length)
						{
							num = 0;
						}
						GamemodeSettings gamemodeSettings = GamemodeFactory.GetGamemodeSettings((GamemodeIDs)num);
						SavedGamemodeSettings savedSettings = MPSaveData.Instance.GetSavedSettings((GamemodeIDs)num);
						if (savedSettings != null)
						{
							gamemodeSettings.ApplySaved(savedSettings);
						}
						lobbyManager.SetGamemode((GamemodeIDs)num, gamemodeSettings);
					});
					base.ScrollView.AddButton(val);
					val = (PhoneButton)(object)PhoneUIUtility.CreateSimpleButton("Gamemode Settings");
					PhoneButton obj4 = val;
					obj4.OnConfirm = (Action)Delegate.Combine(obj4.OnConfirm, (Action)delegate
					{
						((App)this).MyPhone.OpenApp(typeof(AppGamemodeSettings));
					});
					base.ScrollView.AddButton(val);
					val = (PhoneButton)(object)PhoneUIUtility.CreateSimpleButton("Invite Players");
					PhoneButton obj5 = val;
					obj5.OnConfirm = (Action)Delegate.Combine(obj5.OnConfirm, (Action)delegate
					{
						((App)this).MyPhone.OpenApp(typeof(AppMultiplayerLobbyInvite));
					});
					base.ScrollView.AddButton(val);
					val = (PhoneButton)(object)PhoneUIUtility.CreateSimpleButton("Switch Teams");
					PhoneButton obj6 = val;
					obj6.OnConfirm = (Action)Delegate.Combine(obj6.OnConfirm, (Action)delegate
					{
						((App)this).MyPhone.OpenApp(typeof(AppMultiplayerSwitchPlayerTeams));
					});
					base.ScrollView.AddButton(val);
					_allowTeamSwitchingButton = PhoneUIUtility.CreateSimpleButton("Allow Team Switching");
					SimplePhoneButton allowTeamSwitchingButton = _allowTeamSwitchingButton;
					((PhoneButton)allowTeamSwitchingButton).OnConfirm = (Action)Delegate.Combine(((PhoneButton)allowTeamSwitchingButton).OnConfirm, (Action)delegate
					{
						clientController.ClientLobbyManager.SetAllowTeamSwitching(!currentLobby.LobbyState.AllowTeamSwitching);
					});
					base.ScrollView.AddButton((PhoneButton)(object)_allowTeamSwitchingButton);
					_challengeModeButton = PhoneUIUtility.CreateSimpleButton("Public");
					SimplePhoneButton challengeModeButton = _challengeModeButton;
					((PhoneButton)challengeModeButton).OnConfirm = (Action)Delegate.Combine(((PhoneButton)challengeModeButton).OnConfirm, (Action)delegate
					{
						clientController.ClientLobbyManager.SetChallenge(!currentLobby.LobbyState.Challenge);
					});
					base.ScrollView.AddButton((PhoneButton)(object)_challengeModeButton);
				}
				else
				{
					val = (PhoneButton)(object)PhoneUIUtility.CreateSimpleButton("End Game");
					PhoneButton obj7 = val;
					obj7.OnConfirm = (Action)Delegate.Combine(obj7.OnConfirm, (Action)delegate
					{
						if (currentLobby.InGame)
						{
							((App)this).MyPhone.CloseCurrentApp();
							lobbyManager.EndGame();
						}
					});
					base.ScrollView.AddButton(val);
				}
				val = (PhoneButton)(object)PhoneUIUtility.CreateSimpleButton("Kick Players");
				PhoneButton obj8 = val;
				obj8.OnConfirm = (Action)Delegate.Combine(obj8.OnConfirm, (Action)delegate
				{
					((App)this).MyPhone.OpenApp(typeof(AppMultiplayerLobbyKick));
				});
				base.ScrollView.AddButton(val);
			}
			else if (!currentLobby.InGame)
			{
				val = (PhoneButton)(object)PhoneUIUtility.CreateSimpleButton("Switch Team");
				PhoneButton obj9 = val;
				obj9.OnConfirm = (Action)Delegate.Combine(obj9.OnConfirm, (Action)delegate
				{
					//IL_003b: Unknown result type (might be due to invalid IL or missing references)
					//IL_005a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0066: Expected O, but got Unknown
					byte team = lobbyManager.CurrentLobby.LobbyState.Players[clientController.LocalID].Team;
					Team[] teams = GamemodeFactory.GetTeams(lobbyManager.CurrentLobby.LobbyState.Gamemode);
					team++;
					if (team >= teams.Length)
					{
						team = 0;
					}
					clientController.SendPacket((Packet)new ClientSetTeam(team), (SendModes)2, (NetChannels)2);
				});
				base.ScrollView.AddButton(val);
				val = (PhoneButton)(object)PhoneUIUtility.CreateSimpleButton("Toggle Ready");
				PhoneButton obj10 = val;
				obj10.OnConfirm = (Action)Delegate.Combine(obj10.OnConfirm, (Action)delegate
				{
					//IL_002e: Unknown result type (might be due to invalid IL or missing references)
					//IL_003a: Expected O, but got Unknown
					clientController.SendPacket((Packet)new ClientLobbySetReady(!currentLobby.LobbyState.Players[clientController.LocalID].Ready), (SendModes)2, (NetChannels)2);
				});
				base.ScrollView.AddButton(val);
			}
			val = (PhoneButton)(object)PhoneUIUtility.CreateSimpleButton("Leave Lobby");
			PhoneButton obj11 = val;
			obj11.OnConfirm = (Action)Delegate.Combine(obj11.OnConfirm, (Action)delegate
			{
				lobbyManager.LeaveLobby();
				((App)this).MyPhone.CloseCurrentApp();
			});
			base.ScrollView.AddButton(val);
			RefreshLabels();
		}
	}
	public class AppMultiplayerInvites : CustomApp
	{
		public override bool Available => false;

		public static void Initialize()
		{
			PhoneAPI.RegisterApp<AppMultiplayerInvites>("invites", (Sprite)null);
		}

		public override void OnAppInit()
		{
			((CustomApp)this).OnAppInit();
			((CustomApp)this).CreateIconlessTitleBar("Invites", 80f);
			base.ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
		}

		public override void OnAppEnable()
		{
			((App)this).OnAppEnable();
			PopulateButtons();
		}

		private void PopulateButtons()
		{
			base.ScrollView.RemoveAllButtons();
			ClientController clientController = ClientController.Instance;
			ClientLobbyManager lobbyManager = clientController.ClientLobbyManager;
			DateTime now = DateTime.UtcNow;
			IOrderedEnumerable<uint> orderedEnumerable = lobbyManager.LobbiesInvited.OrderBy(delegate(uint x)
			{
				DateTime dateTime = lobbyManager.Lobbies[x].LobbyState.InvitedPlayers[clientController.LocalID];
				return (now - dateTime).TotalSeconds;
			});
			SimplePhoneButton val = PhoneUIUtility.CreateSimpleButton("Ignore all");
			SimplePhoneButton obj = val;
			((PhoneButton)obj).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj).OnConfirm, (Action)delegate
			{
				clientController.ClientLobbyManager.DeclineAllInvites();
				((App)this).MyPhone.CloseCurrentApp();
			});
			base.ScrollView.AddButton((PhoneButton)(object)val);
			foreach (uint invite in orderedEnumerable)
			{
				Lobby lobby = lobbyManager.Lobbies[invite];
				val = PhoneUIUtility.CreateSimpleButton($"({lobby.LobbyState.Players.Count}) {lobbyManager.GetLobbyName(invite)} - {MPUtility.GetPlayerDisplayName(clientController.Players[lobby.LobbyState.HostId].ClientState)}");
				((TMP_Text)val.Label).spriteAsset = MPAssets.Instance.Sprites;
				base.ScrollView.AddButton((PhoneButton)(object)val);
				SimplePhoneButton obj2 = val;
				((PhoneButton)obj2).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj2).OnConfirm, (Action)delegate
				{
					AppMultiplayerAcceptInvite.Show(invite, ((App)this).MyPhone, delegate
					{
						PhoneUtility.BackToHomescreen(((App)this).MyPhone);
						((App)this).MyPhone.OpenApp(typeof(AppMultiplayer));
					}, delegate
					{
						PhoneUtility.BackToHomescreen(((App)this).MyPhone);
						((App)this).MyPhone.OpenApp(typeof(AppMultiplayer));
					});
				});
			}
		}
	}
	public class AppMultiplayerLobbyInvite : PlayerPickerApp
	{
		public static void Initialize()
		{
			PhoneAPI.RegisterApp<AppMultiplayerLobbyInvite>("invite players", (Sprite)null);
		}

		public override void OnAppInit()
		{
			base.OnAppInit();
			((CustomApp)this).CreateIconlessTitleBar("Invite Players", 70f);
		}

		public override void PlayerChosen(ushort[] playerIds)
		{
			base.PlayerChosen(playerIds);
			ClientController instance = ClientController.Instance;
			foreach (ushort playerId in playerIds)
			{
				instance.ClientLobbyManager.InvitePlayer(playerId);
			}
		}
	}
	public class AppMultiplayerLobbyKick : PlayerPickerApp
	{
		public static void Initialize()
		{
			PhoneAPI.RegisterApp<AppMultiplayerLobbyKick>("kick players", (Sprite)null);
		}

		public override void OnAppInit()
		{
			base.OnAppInit();
			((CustomApp)this).CreateIconlessTitleBar("Kick Players", 70f);
		}

		public override bool PlayerFilter(ushort playerId)
		{
			return ClientController.Instance.ClientLobbyManager.CurrentLobby?.LobbyState.Players.ContainsKey(playerId) ?? false;
		}

		public override void PlayerChosen(ushort[] playerIds)
		{
			base.PlayerChosen(playerIds);
			ClientController instance = ClientController.Instance;
			foreach (ushort playerId in playerIds)
			{
				instance.ClientLobbyManager.KickPlayer(playerId);
			}
		}
	}
	public class AppMultiplayerSwitchPlayerTeams : PlayerPickerApp
	{
		public static void Initialize()
		{
			PhoneAPI.RegisterApp<AppMultiplayerSwitchPlayerTeams>("set teams", (Sprite)null);
		}

		public override void OnAppInit()
		{
			base.OnAppInit();
			((CustomApp)this).CreateIconlessTitleBar("Set Teams", 70f);
			AllowEveryone = false;
			AllowMyself = true;
		}

		public override bool PlayerFilter(ushort playerId)
		{
			return ClientController.Instance.ClientLobbyManager.CurrentLobby?.LobbyState.Players.ContainsKey(playerId) ?? false;
		}

		public override void PlayerChosen(ushort[] playerIds)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			ClientLobbyManager clientLobbyManager = ClientController.Instance.ClientLobbyManager;
			_ = clientLobbyManager.CurrentLobby;
			ClientController instance = ClientController.Instance;
			foreach (ushort num in playerIds)
			{
				byte team = clientLobbyManager.CurrentLobby.LobbyState.Players[num].Team;
				team++;
				Team[] teams = GamemodeFactory.GetTeams(clientLobbyManager.CurrentLobby.LobbyState.Gamemode);
				if (team >= teams.Length)
				{
					team = 0;
				}
				instance.SendPacket((Packet)new ClientLobbySetPlayerTeam(num, team), (SendModes)1, (NetChannels)2);
			}
		}
	}
	public class MoveStylePickerApp : CustomApp
	{
		public override bool Available => false;

		public static void Initialize()
		{
			PhoneAPI.RegisterApp<MoveStylePickerApp>("movestyle", (Sprite)null);
		}

		public override void OnAppInit()
		{
			((CustomApp)this).OnAppInit();
			((CustomApp)this).CreateIconlessTitleBar("Movestyle", 80f);
			base.ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
			PopulateButtons();
		}

		private void PopulateButtons()
		{
			base.ScrollView.RemoveAllButtons();
			SimplePhoneButton val = PhoneUIUtility.CreateSimpleButton("Skateboard");
			SimplePhoneButton obj = val;
			((PhoneButton)obj).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj).OnConfirm, (Action)delegate
			{
				SetMoveStyle((MoveStyle)2);
				((App)this).MyPhone.CloseCurrentApp();
				((App)this).MyPhone.OpenApp(typeof(MoveStyleSkinPickerApp));
				(((App)this).MyPhone.m_CurrentApp as MoveStyleSkinPickerApp).PopulateButtons((MoveStyle)2);
			});
			base.ScrollView.AddButton((PhoneButton)(object)val);
			val = PhoneUIUtility.CreateSimpleButton("Inline");
			SimplePhoneButton obj2 = val;
			((PhoneButton)obj2).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj2).OnConfirm, (Action)delegate
			{
				SetMoveStyle((MoveStyle)3);
				((App)this).MyPhone.CloseCurrentApp();
				((App)this).MyPhone.OpenApp(typeof(MoveStyleSkinPickerApp));
				(((App)this).MyPhone.m_CurrentApp as MoveStyleSkinPickerApp).PopulateButtons((MoveStyle)3);
			});
			base.ScrollView.AddButton((PhoneButton)(object)val);
			val = PhoneUIUtility.CreateSimpleButton("BMX");
			SimplePhoneButton obj3 = val;
			((PhoneButton)obj3).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj3).OnConfirm, (Action)delegate
			{
				SetMoveStyle((MoveStyle)1);
				((App)this).MyPhone.CloseCurrentApp();
				((App)this).MyPhone.OpenApp(typeof(MoveStyleSkinPickerApp));
				(((App)this).MyPhone.m_CurrentApp as MoveStyleSkinPickerApp).PopulateButtons((MoveStyle)1);
			});
			base.ScrollView.AddButton((PhoneButton)(object)val);
		}

		private void SetMoveStyle(MoveStyle moveStyle)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_0044: 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)
			SaveManager saveManager = Core.Instance.SaveManager;
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			saveManager.CurrentSaveSlot.GetCharacterProgress(currentPlayer.character).moveStyle = moveStyle;
			MPSaveData.Instance.GetCharacterData(currentPlayer.character).MPMoveStyleSkin = -1;
			currentPlayer.SetCurrentMoveStyleEquipped(moveStyle, true, true);
			currentPlayer.SwitchToEquippedMovestyle(true, false, true, true);
			PlayerComponent.Get(currentPlayer).ApplyMoveStyleSkin(saveManager.CurrentSaveSlot.GetCharacterProgress(currentPlayer.character).moveStyleSkin);
			saveManager.SaveCurrentSaveSlot();
		}
	}
	public class MoveStyleSkinPickerApp : CustomApp
	{
		public override bool Available => false;

		public static void Initialize()
		{
			PhoneAPI.RegisterApp<MoveStyleSkinPickerApp>("movestyle skin picker", (Sprite)null);
		}

		public override void OnAppInit()
		{
			((CustomApp)this).OnAppInit();
			((CustomApp)this).CreateIconlessTitleBar("Movestyle Skin", 80f);
			base.ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
		}

		public void PopulateButtons(MoveStyle moveStyle)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected I4, but got Unknown
			//IL_01a2: 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_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Invalid comparison between Unknown and I4
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Invalid comparison between Unknown and I4
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Invalid comparison between Unknown and I4
			base.ScrollView.RemoveAllButtons();
			StyleSwitchMenu styleSwitchUI = Core.Instance.UIManager.styleSwitchUI;
			StyleSwitchMenu.SortSkinUnlockables(styleSwitchUI.skateboardUnlockables);
			StyleSwitchMenu.SortSkinUnlockables(styleSwitchUI.bmxUnlockables);
			StyleSwitchMenu.SortSkinUnlockables(styleSwitchUI.rollerSkatesUnlockables);
			MoveStyleSkin[] array = null;
			string format = string.Empty;
			switch (moveStyle - 1)
			{
			case 2:
				array = styleSwitchUI.rollerSkatesUnlockables;
				format = "U_MOVESTYLE_SKATES{0}";
				break;
			case 1:
				array = styleSwitchUI.skateboardUnlockables;
				format = "U_MOVESTYLE_DECK{0}";
				break;
			case 0:
				array = styleSwitchUI.bmxUnlockables;
				format = "U_MOVESTYLE_BIKE{0}";
				break;
			}
			foreach (MoveStyleSkin unlock in array)
			{
				SimplePhoneButton val = PhoneUIUtility.CreateSimpleButton(Core.Instance.Localizer.GetSkinText(string.Format(format, unlock.skinIndex + 1), Array.Empty<string>()));
				((PhoneButton)val).OnConfirm = (Action)Delegate.Combine(((PhoneButton)val).OnConfirm, (Action)delegate
				{
					SetVanillaMoveStyleSkin(unlock.skinIndex);
					((App)this).MyPhone.CloseCurrentApp();
				});
				base.ScrollView.AddButton((PhoneButton)(object)val);
			}
			MPUnlockManager instance = MPUnlockManager.Instance;
			MPSaveData instance2 = MPSaveData.Instance;
			foreach (KeyValuePair<int, MPUnlockable> mpUnlockable in instance.UnlockByID)
			{
				bool flag = false;
				if ((mpUnlockable.Key == Animator.StringToHash("goonieskateboard") && !instance2.ShouldDisplayGoonieBoard()) || !(mpUnlockable.Value is MPMoveStyleSkin))
				{
					continue;
				}
				if ((mpUnlockable.Value as MPMoveStyleSkin).MoveStyle == moveStyle)
				{
					flag = true;
				}
				if (((int)(mpUnlockable.Value as MPMoveStyleSkin).MoveStyle != 3 || !(mpUnlockable.Value is MPBuiltInSkin) || PlayerComponent.GetLocal().HasCustomInlines) && ((int)(mpUnlockable.Value as MPMoveStyleSkin).MoveStyle != 2 || !(mpUnlockable.Value is MPBuiltInSkin) || PlayerComponent.GetLocal().HasCustomSkateboard) && ((int)(mpUnlockable.Value as MPMoveStyleSkin).MoveStyle != 1 || !(mpUnlockable.Value is MPBuiltInSkin) || PlayerComponent.GetLocal().HasCustomBmx) && flag)
				{
					SimplePhoneButton val2 = PhoneUIUtility.CreateSimpleButton((mpUnlockable.Value as MPMoveStyleSkin).Title);
					((PhoneButton)val2).OnConfirm = (Action)Delegate.Combine(((PhoneButton)val2).OnConfirm, (Action)delegate
					{
						SetCustomMoveStyleSkin(mpUnlockable.Value as MPMoveStyleSkin);
						((App)this).MyPhone.CloseCurrentApp();
					});
					base.ScrollView.AddButton((PhoneButton)(object)val2);
				}
			}
		}

		private void SetCustomMoveStyleSkin(MPMoveStyleSkin skin)
		{
			//IL_001c: 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)
			SaveManager saveManager = Core.Instance.SaveManager;
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			saveManager.CurrentSaveSlot.GetCharacterProgress(currentPlayer.character).moveStyleSkin = 0;
			MPSaveData.Instance.GetCharacterData(currentPlayer.character).MPMoveStyleSkin = skin.Identifier;
			skin.ApplyToPlayer(currentPlayer);
			saveManager.SaveCurrentSaveSlot();
		}

		private void SetVanillaMoveStyleSkin(int skin)
		{
			//IL_001d: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			SaveManager saveManager = Core.Instance.SaveManager;
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			saveManager.CurrentSaveSlot.GetCharacterProgress(currentPlayer.character).moveStyleSkin = skin;
			MPSaveData.Instance.GetCharacterData(currentPlayer.character).MPMoveStyleSkin = -1;
			PlayerComponent.Get(currentPlayer).ApplyMoveStyleSkin(saveManager.CurrentSaveSlot.GetCharacterProgress(currentPlayer.character).moveStyleSkin);
			saveManager.SaveCurrentSaveSlot();
		}
	}
	public static class PhoneUtility
	{
		public static void BackToHomescreen(Phone phone)
		{
			while (phone.m_PreviousApps.Count > 0)
			{
				phone.DisableApp(((Object)phone.m_CurrentApp).name);
				phone.EnableApp(((Object)phone.m_PreviousApps.Pop()).name);
			}
			phone.audioManager.PlaySfxGameplay((SfxCollectionID)14, (AudioClipID)305, 0f);
		}
	}
	public class PlayerPickerApp : CustomApp
	{
		protected bool AllowEveryone = true;

		protected bool AllowMyself;

		private Dictionary<ushort, PhoneButton> _phoneButtonByPlayerId = new Dictionary<ushort, PhoneButton>();

		private bool _wasConnected = true;

		public override bool Available => false;

		public override void OnAppInit()
		{
			((CustomApp)this).OnAppInit();
			base.ScrollView = PhoneScrollView.Create((CustomApp)(object)this, 275f, 1600f);
		}

		public override void OnAppEnable()
		{
			((App)this).OnAppEnable();
			UnSubToEvents();
			SubToEvents();
			_wasConnected = true;
			PopulateButtons();
		}

		public override void OnAppDisable()
		{
			((App)this).OnAppDisable();
			UnSubToEvents();
		}

		public override void OnAppUpdate()
		{
			((App)this).OnAppUpdate();
			ClientController instance = ClientController.Instance;
			if (instance.Connected != _wasConnected)
			{
				_wasConnected = instance.Connected;
				if (!_wasConnected)
				{
					OnDisconnected();
				}
			}
		}

		private void OnPlayerDisconnected(ushort playerId)
		{
			if (_phoneButtonByPlayerId.TryGetValue(playerId, out var value))
			{
				base.ScrollView.RemoveButton(value);
			}
		}

		private void PopulateButtons()
		{
			_phoneButtonByPlayerId.Clear();
			base.ScrollView.RemoveAllButtons();
			ClientController instance = ClientController.Instance;
			SimplePhoneButton val = null;
			if (AllowEveryone)
			{
				val = PhoneUIUtility.CreateSimpleButton("Everyone");
				base.ScrollView.AddButton((PhoneButton)(object)val);
			}
			foreach (KeyValuePair<ushort, MPPlayer> player in instance.Players.OrderBy((KeyValuePair<ushort, MPPlayer> x) => MPUtility.GetPlayerDisplayName(x.Value.ClientState)).ToDictionary((KeyValuePair<ushort, MPPlayer> x) => x.Key, (KeyValuePair<ushort, MPPlayer> x) => x.Value))
			{
				if ((AllowMyself || player.Value.ClientId != instance.LocalID) && PlayerFilter(player.Value.ClientId))
				{
					SimplePhoneButton val2 = PhoneUIUtility.CreateSimpleButton(MPUtility.GetPlayerDisplayName(player.Value.ClientState));
					((TMP_Text)val2.Label).spriteAsset = MPAssets.Instance.Sprites;
					((PhoneButton)val2).OnConfirm = (Action)Delegate.Combine(((PhoneButton)val2).OnConfirm, (Action)delegate
					{
						PlayerChosen(new ushort[1] { player.Value.ClientId });
					});
					base.ScrollView.AddButton((PhoneButton)(object)val2);
					_phoneButtonByPlayerId[player.Value.ClientId] = (PhoneButton)(object)val2;
				}
			}
			if (AllowEveryone)
			{
				SimplePhoneButton obj = val;
				((PhoneButton)obj).OnConfirm = (Action)Delegate.Combine(((PhoneButton)obj).OnConfirm, (Action)delegate
				{
					PlayerChosen(_phoneButtonByPlayerId.Keys.ToArray());
				});
			}
		}

		public virtual void PlayerChosen(ushort[] playerIds)
		{
			((App)this).MyPhone.CloseCurrentApp();
		}

		public virtual bool PlayerFilter(ushort playerId)
		{
			return true;
		}

		public virtual void OnDisconnected()
		{
			((App)this).MyPhone.CloseCurrentApp();
		}

		private void SubToEvents()
		{
			ClientController.PlayerDisconnected = (Action<ushort>)Delegate.Combine(ClientController.PlayerDisconnected, new Action<ushort>(OnPlayerDisconnected));
		}

		private void UnSubToEvents()
		{
			ClientController.PlayerDisconnected = (Action<ushort>)Delegate.Remove(ClientController.PlayerDisconnected, new Action<ushort>(OnPlayerDisconnected));
		}
	}
	public class StageButton : MonoBehaviour
	{
		private SimplePhoneButton _simplePhoneButton;

		public string StageName = "";

		public Stage Stage;

		private void Awake()
		{
			_simplePhoneButton = ((Component)this).GetComponent<SimplePhoneButton>();
		}

		private void Update()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				((TMP_Text)_simplePhoneButton.Label).text = $"({instance.GetPlayerCountForStage(Stage)}) {StageName}";
			}
		}
	}
}
namespace BombRushMP.Plugin.Patches
{
	[HarmonyPatch(typeof(AmbientManager))]
	internal class AmbientManagerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("Awake")]
		private static void Awake_Prefix(AmbientManager __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (MPUtility.IsChristmas())
			{
				Scene scene = ((Component)__instance).gameObject.scene;
				if (!(((Scene)(ref scene)).name != "hideout"))
				{
					((Component)__instance).transform.rotation = Quaternion.Euler(32f, 337f, 127f);
					__instance.AmbientEnvLight = new Color(0.236f, 0.406f, 0.609f);
					__instance.AmbientEnvShadow = new Color(0.038f, 0.112f, 0.295f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(AmbientTrigger))]
	internal static class AmbientTriggerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerEnter")]
		private static bool OnTriggerEnter_Prefix(Collider trigger)
		{
			Player componentInParent = ((Component)trigger).GetComponentInParent<Player>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return true;
			}
			if (componentInParent.isAI)
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerExit")]
		private static bool OnTriggerExit_Prefix(Collider trigger)
		{
			Player componentInParent = ((Component)trigger).GetComponentInParent<Player>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return true;
			}
			if (componentInParent.isAI)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(AnimationEventRelay))]
	internal static class AnimationEventRelayPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("PlaySound")]
		private static bool PlaySound_Prefix(AnimationEvent animationEvent)
		{
			try
			{
				Enum.Parse(typeof(AudioClipID), animationEvent.stringParameter, ignoreCase: true);
			}
			catch (ArgumentException)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(AudioManager))]
	internal static class AudioManagerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static bool PlayVoice_Prefix(AudioManager __instance, ref VoicePriority currentPriority, Characters character, AudioClipID audioClipID, AudioSource audioSource, VoicePriority playbackPriority)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Invalid comparison between Unknown and I4
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Invalid comparison between Unknown and I4
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Invalid comparison between Unknown and I4
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected I4, but got Unknown
			//IL_00ba: 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_00e9: Expected I4, but got Unknown
			Player componentInParent = ((Component)audioSource).GetComponentInParent<Player>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return true;
			}
			PlayerComponent playerComponent = PlayerComponent.Get(componentInParent);
			if ((Object)(object)playerComponent == (Object)null)
			{
				return true;
			}
			if (playerComponent.HasPropDisguise)
			{
				return false;
			}
			if (playerComponent.StreamedCharacter != null)
			{
				AudioLibrary audioLibrary = playerComponent.StreamedCharacter.Handle.AudioLibrary;
				if ((int)playbackPriority > (int)currentPriority || !audioSource.isPlaying)
				{
					AudioClip random = audioLibrary.GetRandom(audioClipID);
					if ((Object)(object)random == (Object)null)
					{
						return false;
					}
					__instance.PlayNonloopingSfx(audioSource, random, __instance.mixerGroups[5], 0f);
					currentPriority = (VoicePriority)(int)playbackPriority;
				}
				return false;
			}
			if ((int)playerComponent.SpecialSkin == -1)
			{
				return true;
			}
			AudioLibrary audioLibrary2 = SpecialSkinManager.Instance.GetAudioLibrary(playerComponent.SpecialSkin);
			if (audioLibrary2 == null)
			{
				return false;
			}
			if ((int)playbackPriority > (int)currentPriority || !audioSource.isPlaying)
			{
				AudioClip random2 = audioLibrary2.GetRandom(audioClipID);
				if ((Object)(object)random2 == (Object)null)
				{
					return false;
				}
				__instance.PlayNonloopingSfx(audioSource, random2, __instance.mixerGroups[5], 0f);
				currentPriority = (VoicePriority)(int)playbackPriority;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(BMXOnlyGateway))]
	internal static class BMXOnlyGatewayPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerStay")]
		private static bool OnTriggerStay_Prefix(Collider other)
		{
			if (((Component)other).gameObject.layer != 9)
			{
				return true;
			}
			Player componentInParent = ((Component)other).GetComponentInParent<Player>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return true;
			}
			if (componentInParent.isAI)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Boostpack))]
	internal static class BoostpackPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("LateUpdate")]
		private static void LateUpdate_Prefix(Boostpack __instance)
		{
			if ((Object)(object)SpectatorController.Instance != (Object)null)
			{
				__instance.player.cam = GameplayCamera.instance;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("LateUpdate")]
		private static void LateUpdate_Postfix(Boostpack __instance)
		{
			if ((Object)(object)SpectatorController.Instance != (Object)null)
			{
				__instance.player.cam = null;
			}
		}
	}
	[HarmonyPatch(typeof(CameraModeHandplant))]
	internal class CameraModeHandplantPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("UpdatePos")]
		private static bool UpdatePos_Prefix(int fixedFrameCounter, CameraModeHandplant __instance)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ProSkaterPlayer.Get(((CameraMode)__instance).player) == (Object)null)
			{
				return true;
			}
			((CameraMode)__instance).HandleLookAt(fixedFrameCounter, (Vector3?)null);
			if (((CameraMode)__instance).cam.orbitInput != Vector2.zero)
			{
				__instance.goToDefault = false;
			}
			((CameraMode)__instance).position = ((CameraMode)__instance).HandleCamInput(((CameraMode)__instance).position, (Vector2?)null);
			Vector3 position = ((CameraMode)__instance).position;
			Vector3 lookAtPos = ((CameraMode)__instance).lookAtPos;
			Vector3 val = ((CameraMode)__instance).position - ((CameraMode)__instance).lookAtPos;
			((CameraMode)__instance).position = ((CameraMode)__instance).LerpTo(position, lookAtPos + ((Vector3)(ref val)).normalized * ((CameraMode)__instance).cam.handplantCamDist, 2f);
			if (__instance.handPlantAbility.screwSpinTimer > 0f)
			{
				((CameraMode)__instance).manualOrbitFactor = Mathf.Clamp01(((CameraMode)__instance).lastOrbitTimer);
				((CameraMode)__instance).position.y = ((CameraMode)__instance).LerpTo(((CameraMode)__instance).position.y, ((CameraMode)__instance).lookAtPos.y + ((CameraMode)__instance).cam.handplantHeightOffsetDefault, 6f * ((CameraMode)__instance).manualOrbitFactor);
			}
			else if (__instance.goToDefault)
			{
				((CameraMode)__instance).position.y = ((CameraMode)__instance).LerpTo(((CameraMode)__instance).position.y, ((CameraMode)__instance).lookAtPos.y + ((CameraMode)__instance).cam.handplantHeightOffsetDefault, 6f * ((CameraMode)__instance).manualOrbitFactor);
			}
			((CameraMode)__instance).positionFinal = ((CameraMode)__instance).HandleObstructions(((CameraMode)__instance).position);
			return false;
		}
	}
	[HarmonyPatch(typeof(CharacterVisual))]
	internal static class CharacterVisualPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetInlineSkatesPropsMode")]
		private static void SetInlineSkatesPropsMode_Postfix(CharacterVisual __instance, MoveStylePropMode mode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Invalid comparison between Unknown and I4
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0092: 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)
			if ((int)mode != 0 && (int)mode != 2)
			{
				Transform val = __instance.footL.Find("skateOffsetL");
				Transform val2 = __instance.footR.Find("skateOffsetR");
				if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
				{
					__instance.moveStyleProps.skateL.transform.SetLocalPositionAndRotation(val.localPosition, val.localRotation);
					__instance.moveStyleProps.skateL.transform.localScale = val.localScale;
					__instance.moveStyleProps.skateR.transform.SetLocalPositionAndRotation(val2.localPosition, val2.localRotation);
					__instance.moveStyleProps.skateR.transform.localScale = val2.localScale;
				}
			}
		}
	}
	[HarmonyPatch(typeof(DieAbility))]
	internal static class DieAbilityPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("OnStartAbility")]
		private static void OnStartAbility_Postfix(DieAbility __instance)
		{
			if (!((Ability)__instance).p.isAI)
			{
				MPSaveData.Instance.Stats.Deaths++;
				MPUtility.CloseMenusAndSpectator();
				ClientController.Instance.SendGenericEvent((GenericEvents)3, (SendModes)2);
				if (MPSettings.Instance.DeathSequence)
				{
					DeathSequenceController.Create();
				}
			}
		}
	}
	[HarmonyPatch(typeof(DieMenu))]
	internal static class DieMenuPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("InitButtons")]
		private static void InitButtons_Postfix(DieMenu __instance)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			((UnityEventBase)__instance.resumeBtn.onClick).RemoveAllListeners();
			((UnityEvent)__instance.resumeBtn.onClick).AddListener((UnityAction)delegate
			{
				if (CanRevive())
				{
					MPUtility.Revive();
				}
				else
				{
					((AMenuController)__instance).uIManager.HideDieMenu();
					Core.Instance.BaseModule.StageManager.RestartStage();
					__instance.baseModule.UnPauseGame((PauseType)256);
				}
			});
		}

		private static bool CanRevive()
		{
			WorldHandler instance = WorldHandler.instance;
			if (!ClientController.Instance.Connected)
			{
				return false;
			}
			Encounter currentEncounter = instance.currentEncounter;
			if ((Object)(object)currentEncounter != (Object)null && !(currentEncounter is ProxyEncounter))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("Activate")]
		private static bool Activate_Prefix()
		{
			if (!WorldHandler.instance.GetCurrentPlayer().IsDead())
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(GameplayUI))]
	internal static class GameplayUIPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Init")]
		private static void Init_Postfix(GameplayUI __instance)
		{
			SpectatorUI.InitializeUI(__instance);
			PropHuntUI.InitializeUI(__instance);
		}
	}
	[HarmonyPatch(typeof(GraffitiGame))]
	internal static class GraffitiGamePatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Play")]
		private static void Play_Postfix(GraffitiGame __instance, string anim)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			ClientController instance = ClientController.Instance;
			if (!((Object)(object)instance == (Object)null) && instance.Connected)
			{
				instance.SendPacket((Packet)new PlayerAnimation(Animator.StringToHash(anim), false, false, -1f), PlayerAnimation.ClientSendMode, (NetChannels)5);
				if (anim == "grafSlashFinisher")
				{
					instance.SendPacket((Packet)new PlayerGraffitiFinisher((byte)__instance.gSpot.size), (SendModes)2, (NetChannels)3);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("PlayPuppetSlashAnim")]
		private static void PlayPuppetSlashAnim_Postfix(Side side, bool outAnim)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			ClientController instance = ClientController.Instance;
			if (!((Object)(object)instance == (Object)null) && instance.Connected)
			{
				instance.SendPacket((Packet)new PlayerAnimation(Animator.StringToHash("grafSlash" + ((object)(Side)(ref side)).ToString() + (outAnim ? "_Out" : "")), false, false, -1f), PlayerAnimation.ClientSendMode, (NetChannels)5);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("DoGraffitiEffect")]
		private static void DoGraffitiEffect_Postfix(GraffitiGame __instance)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			ClientController instance = ClientController.Instance;
			if (!((Object)(object)instance == (Object)null) && instance.Connected)
			{
				instance.SendPacket((Packet)new PlayerGraffitiSlash(__instance.slashCardinal.ToSystemVector3()), (SendModes)2, (NetChannels)3);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetState")]
		private static void SetState_Prefix(GraffitiGame __instance, GraffitiGameState setState)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)setState != 2)
			{
				return;
			}
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Lobby currentLobby = instance.ClientLobbyManager.CurrentLobby;
			if (currentLobby != null && currentLobby.InGame && currentLobby.CurrentGamemode is GraffitiRace)
			{
				GraffitiRace graffitiRace = currentLobby.CurrentGamemode as GraffitiRace;
				if (graffitiRace.IsRaceGraffitiSpot(__instance.gSpot))
				{
					graffitiRace.AddScore(__instance.gSpot);
					graffitiRace.MarkGraffitiSpotDone(__instance.gSpot);
				}
			}
		}
	}
	[HarmonyPatch(typeof(GraffitiSpot))]
	internal static class GraffitiSpotPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("WriteToData")]
		private static bool WriteToData_Prefix(GraffitiSpot __instance)
		{
			Lobby currentLobby = ClientController.Instance.ClientLobbyManager.CurrentLobby;
			if (currentLobby != null && currentLobby.InGame && currentLobby.CurrentGamemode is GraffitiRace)
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("PaintChanged")]
		private static bool PaintChanged_Prefix(GraffitiSpot __instance)
		{
			//IL_0058: 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)
			Lobby lobby = ClientController.Instance?.ClientLobbyManager?.CurrentLobby;
			if (lobby != null && lobby.InGame && lobby.CurrentGamemode is GraffitiRace)
			{
				__instance.emptyGraffitiMaterial.color = Theme.CurrentTheme.RaceGraffitiSwirlColor;
			}
			else
			{
				__instance.emptyGraffitiMaterial.color = Theme.CurrentTheme.GraffitiSwirlColor;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(GrindAbility))]
	internal class GrindAbilityPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("JumpOut")]
		private static void JumpOut_Prefix(GrindAbility __instance)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			if (((Ability)__instance).p.isAI)
			{
				return;
			}
			PlayerComponent playerComponent = PlayerComponent.Get(((Ability)__instance).p);
			if (!((Object)(object)playerComponent != (Object)null) || !playerComponent.HasPropDisguise)
			{
				ClientController instance = ClientController.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.Connected)
				{
					PlayerVoice val = new PlayerVoice();
					val.AudioClipId = 489;
					val.VoicePriority = 0;
					instance.SendPacket((Packet)(object)val, (SendModes)2, (NetChannels)3);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("CanSetToLine")]
		private static bool CanSetToLine_Prefix(GrindAbility __instance, ref bool __result)
		{
			PropDisguiseController instance = PropDisguiseController.Instance;
			if ((Object)(object)instance != (Object)null && instance.InPropHunt && instance.LocalPropHuntTeam == PropHuntTeams.Props)
			{
				__result = false;
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetToLine")]
		private static bool SetToLine_Prefix(GrindAbility __instance)
		{
			if (((Ability)__instance).p.isAI)
			{
				return true;
			}
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			if (!instance.Connected)
			{
				return true;
			}
			instance.SendGenericEvent((GenericEvents)1, (SendModes)2);
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch("OnStopAbility")]
		private static void OnStopAbility_Postfix(GrindAbility __instance)
		{
			if (((Ability)__instance).p.isAI)
			{
				return;
			}
			ProSkaterPlayer proSkaterPlayer = ProSkaterPlayer.Get(((Ability)__instance).p);
			if ((Object)(object)proSkaterPlayer != (Object)null)
			{
				if (((Ability)__instance).p.abilityTimer <= 0.125f)
				{
					proSkaterPlayer.PenalizeGrinding();
				}
				else
				{
					proSkaterPlayer.SoftResetGrinding();
				}
				proSkaterPlayer.GrindBalance.CurrentSensitivity += 0.0025f;
			}
			ClientController instance = ClientController.Instance;
			if (!((Object)(object)instance == (Object)null) && instance.Connected)
			{
				instance.SendGenericEvent((GenericEvents)1, (SendModes)2);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("UpdateTilting")]
		private static bool UpdateTilting_Prefix(GrindAbility __instance)
		{
			if (((Ability)__instance).p.isAI)
			{
				return true;
			}
			ProSkaterPlayer proSkaterPlayer = ProSkaterPlayer.Get(((Ability)__instance).p);
			if ((Object)(object)proSkaterPlayer == (Object)null)
			{
				return true;
			}
			proSkaterPlayer.GrindUpdateTilting(__instance);
			return false;
		}
	}
	[HarmonyPatch(typeof(HandplantAbility))]
	internal class HandplantAbilityPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("OnStopAbility")]
		private static void OnStopAbility_Postfix(HandplantAbility __instance)
		{
			if (((Ability)__instance).p.isAI)
			{
				return;
			}
			ProSkaterPlayer proSkaterPlayer = ProSkaterPlayer.Get(((Ability)__instance).p);
			if ((Object)(object)proSkaterPlayer != (Object)null)
			{
				if (((Ability)__instance).p.abilityTimer <= 0.125f)
				{
					proSkaterPlayer.PenalizeGrinding();
				}
				else
				{
					proSkaterPlayer.SoftResetGrinding();
				}
			}
		}
	}
	internal static class InputPatch
	{
		private static MethodInfo GetKeyDown_Base_KeyCodeOverload = AccessTools.Method(typeof(Input), "GetKeyDown", new Type[1] { typeof(KeyCode) }, (Type[])null);

		private static MethodInfo GetKeyDown_Base_StringOverload = AccessTools.Method(typeof(Input), "GetKeyDown", new Type[1] { typeof(string) }, (Type[])null);

		private static MethodInfo GetKeyDown_Prefix_Method = AccessTools.Method(typeof(InputPatch), "GetKeyDown_Prefix", (Type[])null, (Type[])null);

		internal static void Patch(Harmony harmony)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			HarmonyMethod val = new HarmonyMethod(GetKeyDown_Prefix_Method);
			harmony.Patch((MethodBase)GetKeyDown_Base_KeyCodeOverload, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)GetKeyDown_Base_StringOverload, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static bool GetKeyDown_Prefix(ref bool __result)
		{
			if (InputUtils.InputBlocked)
			{
				__result = false;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Junk))]
	internal static class JunkPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerStay")]
		private static bool OnTriggerStay_Prefix(Collider other)
		{
			PropDisguiseController instance = PropDisguiseController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			if (instance.FrozenProps)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(KeyboardShortcut))]
	internal class KeyboardShortcutPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("IsDown")]
		private static bool IsDown_Prefix(ref bool __result)
		{
			if (InputUtils.InputBlocked)
			{
				__result = false;
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("IsPressed")]
		private static bool IsPressed_Prefix(ref bool __result)
		{
			if (InputUtils.InputBlocked)
			{
				__result = false;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Mapcontroller))]
	internal static class MapcontrollerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("UpdateCamera")]
		private static bool UpdateCamera_Prefix(Mapcontroller __instance)
		{
			if ((Object)(object)__instance.m_Player == (Object)null)
			{
				return false;
			}
			if ((Object)(object)__instance.m_Player.cam == (Object)null)
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("DisableMapCamera")]
		private static bool DisableMapCamera_Prefix(Mapcontroller __instance)
		{
			MPMapController instance = MPMapController.Instance;
			if ((Object)(object)instance != (Object)null && instance.BeingDisplayed)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(MapPin))]
	internal static class MapPinPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetupMapPin")]
		private static void SetupMapPin_Postfix(MapPin __instance)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Invalid comparison between Unknown and I4
			ClientController instance = ClientController.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				Lobby currentLobby = instance.ClientLobbyManager.CurrentLobby;
				if (currentLobby != null && currentLobby.InGame && currentLobby.CurrentGamemode is GraffitiRace && (int)__instance.m_pinType == 1)
				{
					__instance.DisableMapPinGameObject();
				}
			}
		}
	}
	[HarmonyPatch(typeof(NPC))]
	internal static class NPCPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("SetAvailable")]
		private static bool SetAvailable_Prefix(bool set, NPC __instance)
		{
			if ((Object)(object)((Component)__instance).GetComponent<Taxi>() == (Object)null)
			{
				return true;
			}
			Encounter currentEncounter = WorldHandler.instance.currentEncounter;
			if (!set && (Object)(object)currentEncounter != (Object)null && currentEncounter is ProxyEncounter && ((GameplayEvent)__instance).available)
			{
				((GameplayEvent)__instance).available = false;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(OptionsMenu))]
	public static class OptionsMenuPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		private static void Awake_Postfix(OptionsMenu __instance)
		{
			PatchGameTab(__instance);
			PatchAudioTab(__instance);
		}

		private static void PatchGameTab(OptionsMenu optionsMenu)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00fc: Expected O, but got Unknown
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			OptionsMenuGameTab componentInChildren = ((Component)optionsMenu).GetComponentInChildren<OptionsMenuGameTab>();
			Transform val = ((AOptionsMenuTab)componentInChildren).settingsContainer.transform.Find("GameTabSettingsInvertAxisContainer");
			GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject);
			((Object)val2.gameObject).name = "GameTabSettingsShowNamePlatesContainer";
			((TMP_Text)((Component)val2.transform.Find("MultiSelectionButton")).GetComponentInChildren<TextMeshProUGUI>()).text = "Show nameplates";
			val2.transform.SetParent(((Component)val).transform.parent, false);
			val2.transform.localPosition = new Vector3(val2.transform.localPosition.x, -10f, val2.transform.localPosition.z);
			Object.Destroy((Object)(object)val2.GetComponentInChildren<TMProLocalizationAddOn>());
			MultiOptionButton multiOptionButton = val2.GetComponentInChildren<MultiOptionButton>();
			MPSettings instance = MPSettings.Instance;
			multiOptionButton.SetLabelText(instance.ShowNamePlates ? "On" : "Off");
			multiOptionButton.OnChanged += (SelectionChangedDelegate)delegate
			{
				MPSettings instance2 = MPSettings.Instance;
				instance2.ShowNamePlates = !instance2.ShowNamePlates;
				instance2.Save();
				multiOptionButton.SetLabelText(instance2.ShowNamePlates ? "On" : "Off");
			};
			((AOptionsMenuTab)componentInChildren).textSelectables = CollectionExtensions.AddItem<ITextSelectable>((IEnumerable<ITextSelectable>)((AOptionsMenuTab)componentInChildren).textSelectables, (ITextSelectable)(object)multiOptionButton).ToArray();
			MultiOptionButton componentInChildren2 = ((Component)((AOptionsMenuTab)componentInChildren).settingsContainer.transform.Find("GameTabSettingsLanguageContainer")).GetComponentInChildren<MultiOptionButton>();
			TextMeshProMenuButton componentInChildren3 = ((Component)((AOptionsMenuTab)componentInChildren).settingsContainer.transform.Find("GameTabApplyLanguageButton")).GetComponentInChildren<TextMeshProMenuButton>();
			Navigation navigation = default(Navigation);
			((Navigation)(ref navigation)).selectOnUp = (Selectable)(object)componentInChildren2;
			((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)componentInChildren3;
			((Navigation)(ref navigation)).mode = (Mode)4;
			((Selectable)multiOptionButton).navigation = navigation;
			navigation = ((Selectable)componentInChildren2).navigation;
			((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)multiOptionButton;
			((Selectable)componentInChildren2).navigation = navigation;
			navigation = ((Selectable)componentInChildren3).navigation;
			((Navigation)(ref navigation)).selectOnUp = (Selectable)(object)multiOptionButton;
			((Selectable)componentInChildren3).navigation = navigation;
		}

		private static void PatchAudioTab(OptionsMenu optionsMenu)
		{
			//IL_0059: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Expected O, but got Unknown
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: 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_01d5: 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)
			OptionsMenuGameTab componentInChildren = ((Component)optionsMenu).GetComponentInChildren<OptionsMenuGameTab>();
			OptionsMenuAudioTab componentInChildren2 = ((Component)optionsMenu).GetComponentInChildren<OptionsMenuAudioTab>();
			GameObject val = Object.Instantiate<GameObject>(((Component)((AOptionsMenuTab)componentInChildren).settingsContainer.transform.Find("GameTabSettingsInvertAxisContainer")).gameObject);
			val.transform.SetParent(((AOptionsMenuTab)componentInChildren2).settingsContainer.transform, false);
			GameObjectExtensions.RectTransform(val).anchorMin = new Vector2(0f, 0.69f);
			GameObjectExtensions.RectTransform(val).anchorMax = new Vector2(1f, 1f);
			val.transform.localPosition = new Vector3(val.transform.localPosition.x, -60f, val.transform.localPosition.z);
			((TMP_Text)((Component)val.transform.Find("MultiSelectionButton")).GetComponentInChildren<TextMeshProUGUI>()).text = "Player voices";
			((Object)val.gameObject).name = "AudioTabSettingsPlayerVoicesContainer";
			((Component)val.transform.Find("OptionsLabel")).transform.localPosition = new Vector3(117f, 0f, 0f);
			MultiOptionButton multiOptionButton = val.GetComponentInChildren<MultiOptionButton>();
			Object.Destroy((Object)(object)val.GetComponentInChildren<TMProLocalizationAddOn>());
			MPSettings instance = MPSettings.Instance;
			multiOptionButton.SetLabelText(instance.PlayerAudioEnabled ? "On" : "Off");
			multiOptionButton.OnChanged += (SelectionChangedDelegate)delegate
			{
				MPSettings instance2 = MPSettings.Instance;
				instance2.PlayerAudioEnabled = !instance2.PlayerAudioEnabled;
				instance2.Save();
				multiOptionButton.SetLabelText(instance2.PlayerAudioEnabled ? "On" : "Off");
			};
			TextMeshProMenuButton componentInChildren3 = ((Component)((Component)optionsMenu).transform.Find("OptionsMenuBottomButtonContainer").Find("BackButton")).GetComponentInChildren<TextMeshProMenuButton>();
			OptionsSliderButton componentInChildren4 = ((Component)((AOptionsMenuTab)componentInChildren2).settingsContainer.transform.Find("AudioTabMusicVolumeContainer")).GetComponentInChildren<OptionsSliderButton>();
			Navigation navigation = default(Navigation);
			((Navigation)(ref navigation)).selectOnUp = (Selectable)(object)componentInChildren4;
			((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)componentInChildren3;
			((Navigation)(ref navigation)).mode = (Mode)4;
			((Selectable)multiOptionButton).navigation = navigation;
			navigation = ((Selectable)componentInChildren4).navigation;
			((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)multiOptionButton;
			((Selectable)componentInChildren4).navigation = navigation;
			((AOptionsMenuTab)componentInChildren2).lastSelectable = ((Component)multiOptionButton).gameObject;
			((AOptionsMenuTab)componentInChildren2).textSelectables = CollectionExtensions.AddItem<ITextSelectable>((IEnumerable<ITextSelectable>)((AOptionsMenuTab)componentInChildren2).textSelectables, (ITextSelectable)(object)multiOptionButton).ToArray();
		}
	}
	[HarmonyPatch(typeof(Phone))]
	internal static class PhonePatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("OpenCloseHandeling")]
		private static bool OpenCloseHandeling_Prefix(Phone __instance, ref bool __state)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			__state = (int)__instance.state == 1;
			if ((Object)(object)SpectatorController.Instance != (Object)null)
			{
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch("OpenCloseHandeling")]
		private static void OpenCloseHandeling_Postfix(Phone __instance, ref bool __state)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			if (!__state && (int)__instance.state == 1 && __instance.gameInput.GetButtonNew(21, 0))
			{
				PhoneUtility.BackToHomescreen(__instance);
				__instance.OpenApp(typeof(AppMultiplayer));
				if (NotificationController.Instance.HasNotificationUp)
				{
					__instance.OpenApp(typeof(AppMultiplayerInvites));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player))]
	internal static class PlayerPatch
	{
		internal static bool PlayAnimPatchEnabled = true;

		[HarmonyPrefix]
		[HarmonyPatch("OnCollisionEnter")]
		private static bool OnCollisionEnter_Prefix(Collision other)
		{
			PropDisguiseController instance = PropDisguiseController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			if (!instance.FrozenProps)
			{
				return true;
			}
			if (other.gameObject.layer == 21)
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("PlayAnim")]
		private static bool PlayAnim_Prefix(Player __instance, int newAnim, bool forceOverwrite, bool instant, float atTime)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.isAI && newAnim == __instance.idleFidget1Hash && PlayerComponent.Get(__instance).AFK)
			{
				return false;
			}
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			if (instance.Connected && !__instance.isAI)
			{
				if (__instance.inGraffitiGame)
				{
					return true;
				}
				PlayerAnimation val = new PlayerAnimation(newAnim, forceOverwrite, instant, atTime);
				int newAnim2 = default(int);
				if (BunchOfEmotesSupport.TryGetCustomAnimationHashByGameAnimation(newAnim, ref newAnim2))
				{
					val.BoE = true;
					val.NewAnim = newAnim2;
				}
				instance.SendPacket((Packet)(object)val, PlayerAnimation.ClientSendMode, (NetChannels)5);
			}
			if (!PlayAnimPatchEnabled)
			{
				return true;
			}
			if (MPUtility.IsMultiplayerPlayer(__instance))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("UpdateSprayCanShake")]
		private static bool UpdateSprayCanShake_Prefix(Player __instance)
		{
			if (PropDisguiseController.Instance.InPropHunt)
			{
				__instance.SetSpraycanState((SpraycanState)0);
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch("InitAbilities")]
		private static void InitAbilities_Postfix(Player __instance)
		{
			if (!__instance.isAI)
			{
				PlayerComponent.Get(__instance).InitAbilities();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("ActivateAbility")]
		private static bool ActivateAbility_Prefix(Ability a, Player __instance)
		{
			if (__instance.isAI)
			{
				return true;
			}
			if (__instance.ability is PseudoDieAbility)
			{
				return false;
			}
			PropDisguiseController instance = PropDisguiseController.Instance;
			if (instance.InPropHunt)
			{
				if (instance.LocalPropHuntTeam == PropHuntTeams.Props && (a is WallrunLineAbility || a is BoostAbility))
				{
					return false;
				}
				if (a is DieAbility)
				{
					PlayerComponent local = PlayerComponent.GetLocal();
					if (local.HasPropDisguise)
					{
						local.RemovePropDisguise();
					}
					__instance.ActivateAbility((Ability)(object)local.PseudoDieAbility);
					(ClientController.Instance.ClientLobbyManager.CurrentLobby.CurrentGamemode as PropHunt).OnDie();
					return false;
				}
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("FixedUpdatePlayer")]
		private static bool FixedUpdatePlayer_Prefix(Player __instance)
		{
			if (!__instance.isAI && (Object)(object)ClientController.Instance != (Object)null && (Object)(object)ClientController.Instance.PlayerAttached != (Object)null)
			{
				__instance.UpdateAnim();
				return false;
			}
			if (MPUtility.IsMultiplayerPlayer(__instance))
			{
				__instance.UpdateAnim();
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("PickupVisualization")]
		private static bool PickupVisualization_Prefix(Player __instance)
		{
			if ((Object)(object)__instance.cam == (Object)null)
			{
				return false;
			}
			if ((Object)(object)__instance.cam.cam == (Object)null)
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("PlayVoice")]
		private static bool PlayVoice_Prefix(Player __instance, AudioClipID audioClipID, VoicePriority voicePriority)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected I4, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected I4, but got Unknown
			if (__instance.isAI)
			{
				return true;
			}
			PlayerComponent playerComponent = PlayerComponent.Get(__instance);
			if ((Object)(object)playerComponent != (Object)null && playerComponent.HasPropDisguise)
			{
				return false;
			}
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			if (!instance.Connected)
			{
				return true;
			}
			PlayerVoice val = new PlayerVoice();
			val.AudioClipId = (int)audioClipID;
			val.VoicePriority = (int)voicePriority;
			instance.SendPacket((Packet)(object)val, (SendModes)2, (NetChannels)3);
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("ChangeHP")]
		private static void ChangeHP_Prefix(Player __instance, int dmg)
		{
			if (!__instance.isAI && dmg > 0)
			{
				PropHuntPlayer component = ((Component)__instance).GetComponent<PropHuntPlayer>();
				if ((Object)(object)component != (Object)null)
				{
					component.Unfreeze();
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("Jump")]
		private static void Jump_Prefix(Player __instance)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			if (__instance.isAI)
			{
				return;
			}
			PlayerComponent playerComponent = PlayerComponent.Get(__instance);
			if (!((Object)(object)playerComponent != (Object)null) || !playerComponent.HasPropDisguise)
			{
				ClientController instance = ClientController.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.Connected)
				{
					PlayerVoice val = new PlayerVoice();
					val.AudioClipId = 489;
					val.VoicePriority = 0;
					instance.SendPacket((Packet)(object)val, (SendModes)2, (NetChannels)3);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerStay")]
		private static bool OnTriggerStay_Prefix(Player __instance, Collider other)
		{
			//IL_0066: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			if (MPUtility.IsMultiplayerPlayer(__instance))
			{
				return false;
			}
			if (((Component)other).gameObject.layer == 20 && __instance.ability != __instance.knockbackAbility)
			{
				if (!PvPUtils.CanIGetHit())
				{
					return true;
				}
				Player componentInParent = ((Component)other).gameObject.GetComponentInParent<Player>();
				if ((Object)(object)componentInParent == (Object)null)
				{
					return true;
				}
				if (PvPUtils.CanReptilePlayerPvP(componentInParent))
				{
					bool flag = PvPUtils.CanIGetDamaged();
					bool num = flag;
					Vector3 val = ((Component)componentInParent).transform.position - ((Component)__instance).transform.position;
					__instance.GetHit(num ? 1 : 0, ((Vector3)(ref val)).normalized, (KnockbackType)1);
					MPSaveData.Instance.Stats.TimesHit++;
					Core.Instance.SaveManager.SaveCurrentSaveSlot();
					MPPlayer muliplayerPlayer = MPUtility.GetMuliplayerPlayer(componentInParent);
					ClientController.Instance.SendPacket((Packet)new ClientHitByPlayer(muliplayerPlayer.ClientId), (SendModes)2, (NetChannels)0);
				}
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch("OnTriggerStay")]
		private static void OnTriggerStay_Postfix(Player __instance)
		{
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			ClientLobbyManager clientLobbyManager = instance.ClientLobbyManager;
			if (clientLobbyManager != null)
			{
				Lobby currentLobby = clientLobbyManager.CurrentLobby;
				if (currentLobby != null && currentLobby.CurrentGamemode != null && currentLobby.InGame && currentLobby.CurrentGamemode is GraffitiRace graffitiRace && graffitiRace.QuickGraffitiEnabled && graffitiRace.AutoGraffitiEnabled)
				{
					__instance.graffitiContextAvailable = 0;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("InitHitboxes")]
		private static void InitHitboxes_Postfix(Player __instance)
		{
			if (__instance.isAI)
			{
				MPUtility.PlayerHitboxesToEnemy(__instance);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("CheckWallrun")]
		private static bool CheckWallrun_Prefix(Player __instance)
		{
			if (MPUtility.IsMultiplayerPlayer(__instance))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("CheckVert")]
		private static bool CheckVert_Prefix(Player __instance, ref bool __result)
		{
			if (MPUtility.IsMultiplayerPlayer(__instance))
			{
				__result = false;
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("StartHitpause")]
		private static bool StartHitpause_Prefix(Player __instance)
		{
			if (MPUtility.IsMultiplayerPlayer(__instance))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetOutfit")]
		private static bool SetOutfit_Prefix(Player __instance, int setOutfit)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if ((int)PlayerComponent.Get(__instance).SpecialSkin == -1)
			{
				return true;
			}
			if (!__instance.isAI)
			{
				Core.Instance.SaveManager.CurrentSaveSlot.GetCharacterProgress(__instance.character).outfit = setOutfit;
			}
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch("SetOutfit")]
		private static void SetOutfit_Postfix(Player __instance)
		{
			ClientController instance = ClientController.Instance;
			if (!((Object)(object)instance == (Object)null) && instance.Connected && !__instance.isAI)
			{
				instance.SendClientState();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("InitVisual")]
		private static void InitVisual_Postfix(Player __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Invalid comparison between Unknown and I4
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Invalid comparison between Unknown and I4
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Invalid comparison between Unknown and I4
			PlayerComponent playerComponent = PlayerComponent.Get(__instance);
			playerComponent.CacheNewSkin();
			if (__instance.isAI)
			{
				return;
			}
			bool justCreated;
			MPSaveData.MPCharacterData characterData = MPSaveData.Instance.GetCharacterData(__instance.character, out justCreated);
			CharacterProgress characterProgress = Core.Instance.SaveManager.CurrentSaveSlot.GetCharacterProgress(__instance.character);
			if (justCreated)
			{
				if (playerComponent.HasCustomInlines && (int)characterProgress.moveStyle == 3)
				{
					characterData.MPMoveStyleSkin = 6969420;
				}
				else if (playerComponent.HasCustomBmx && (int)characterProgress.moveStyle == 1)
				{
					characterData.MPMoveStyleSkin = 6767420;
				}
				else if (playerComponent.HasCustomSkateboard && (int)characterProgress.moveStyle == 2)
				{
					characterData.MPMoveStyleSkin = 5318008;
				}
			}
			if (characterData.MPMoveStyleSkin != -1)
			{
				MPUnlockManager instance = MPUnlockManager.Instance;
				if (instance.UnlockByID.ContainsKey(characterData.MPMoveStyleSkin) && instance.UnlockByID[characterData.MPMoveStyleSkin] is MPMoveStyleSkin mPMoveStyleSkin)
				{
					mPMoveStyleSkin.ApplyToPlayer(__instance);
				}
			}
			else
			{
				playerComponent.ApplyMoveStyleSkin(characterProgress.moveStyleSkin);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("SetCharacter")]
		private static void SetCharacter_Postfix(Characters setChar, Player __instance)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			PlayerComponent playerComponent = PlayerComponent.Get(__instance);
			playerComponent.Chibi = false;
			playerComponent.SpecialSkin = (SpecialSkins)(-1);
			playerComponent.UnloadStreamedCharacter();
			ClientController instance = ClientController.Instance;
			if (!((Object)(object)instance == (Object)null) && instance.Connected && !__instance.isAI)
			{
				instance.SendClientState();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("OrientVisualToSurface")]
		private static bool OrientVisualToSurface_Prefix(Player __instance)
		{
			if (MPUtility.IsMultiplayerPlayer(__instance))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("UpdateVisualRot")]
		private static bool UpdateVisualRot_Prefix(Player __instance)
		{
			if (MPUtility.IsMultiplayerPlayer(__instance))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetInputs")]
		private static void SetInputs_Prefix(Player __instance, ref InputBuffer inputBuffer)
		{
			if (!__instance.isAI)
			{
				ProSkaterPlayer proSkaterPlayer = ProSkaterPlayer.Get(__instance);
				if (!((Object)(object)proSkaterPlayer == (Object)null) && proSkaterPlayer.IsOnManual())
				{
					inputBuffer.moveAxisY = 0f;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("SetInputs")]
		private static void SetInputs_Postfix(Player __instance)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			if (!__instance.isAI)
			{
				return;
			}
			MPPlayer muliplayerPlayer = MPUtility.GetMuliplayerPlayer(__instance);
			if (muliplayerPlayer != null)
			{
				__instance.sprayButtonHeld = muliplayerPlayer.ClientVisualState.SprayCanHeld;
				if (!muliplayerPlayer.ClientVisualState.SprayCanHeld && (int)__instance.spraycanState != 3)
				{
					__instance.SetSpraycanState((SpraycanState)0);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetSpraycanState")]
		private static void SetSpraycanState_Prefix(Player __instance, SpraycanState state)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			if (!__instance.isAI)
			{
				ClientController instance = ClientController.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.Connected && (int)state == 3)
				{
					instance.SendGenericEvent((GenericEvents)0, (SendModes)2);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("CompletelyStop")]
		private static void CompletelyStop_Postfix(Player __instance)
		{
			if (!__instance.isAI)
			{
				ClientController instance = ClientController.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.Connected)
				{
					instance.SendGenericEvent((GenericEvents)1, (SendModes)2);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerEnter")]
		private static bool OnTriggerEnter_Prefix(Player __instance)
		{
			if (MPUtility.IsMultiplayerPlayer(__instance))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("LateUpdateAnimation")]
		private static bool LateUpdateAnimation_Prefix(Player __instance)
		{
			if (!MPUtility.IsMultiplayerPlayer(__instance))
			{
				return true;
			}
			if (__instance.characterVisual.canBlink)
			{
				Player.UpdateBlinkAnimation(__instance.characterVisual.mainRenderer, __instance.characterMesh, ref __instance.blinkTimer, ref __instance.blink, ref __instance.blinkDuration, Core.dt);
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch("CheckAvailableGraffitiSpots")]
		private static bool CheckAvailableGraffitiSpots_Prefix(Player __instance)
		{
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			ClientLobbyManager clientLobbyManager = instance.ClientLobbyManager;
			if (clientLobbyManager == null)
			{
				return true;
			}
			Lobby currentLobby = clientLobbyManager.CurrentLobby;
			if (currentLobby == null || currentLobby.CurrentGamemode == null || !currentLobby.InGame)
			{
				return true;
			}
			if (currentLobby.CurrentGamemode is PropHunt)
			{
				return false;
			}
			if (!(currentLobby.CurrentGamemode is GraffitiRace graffitiRace))
			{
				return true;
			}
			if (!graffitiRace.QuickGraffitiEnabled)
			{
				return true;
			}
			if (!graffitiRace.AutoGraffitiEnabled)
			{
				return true;
			}
			GraffitiSpot val = null;
			foreach (GraffitiSpot item in __instance.graffitiSpotsAvailable)
			{
				if (graffitiRace.IsRaceGraffitiSpot(item))
				{
					val = item;
					break;
				}
			}
			if ((Object)(object)val != (Object)null && __instance.userInputEnabled)
			{
				__instance.StartGraffitiMode(val);
				__instance.graffitiSpotsAvailable.Clear();
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch("StartGraffitiMode")]
		private static bool StartGraffitiMode_Prefix(Player __instance, GraffitiSpot graffitiSpot)
		{
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Invalid comparison between Unknown and I4
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Invalid comparison between Unknown and I4
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Invalid comparison between Unknown and I4
			//IL_00af: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.IsBusyWithSequence() || __instance.IsDead() || __instance.ability == __instance.danceAbility || __instance.isAI)
			{
				return true;
			}
			ClientController instance = ClientController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			ClientLobbyManager clientLobbyManager = instance.ClientLobbyManager;
			if (clientLobbyManager == null)
			{
				return true;
			}
			Lobby currentLobby = clientLobbyManager.CurrentLobby;
			if (currentLobby == null || currentLobby.CurrentGamemode == null || !currentLobby.InGame)
			{
				return true;
			}
			if (!(currentLobby.CurrentGamemode is GraffitiRace graffitiRace))
			{
				return true;
			}
			if (!graffitiRace.QuickGraffitiEnabled)
			{
				return true;
			}
			if (graffitiRace.IsRaceGraffitiSpot(graffitiSpot))
			{
				graffitiRace.AddScore(graffitiSpot);
				graffitiRace.MarkGraffitiSpotDone(graffitiSpot);
			}
			TrickType val = (TrickType)16;
			if ((int)graffitiSpot.size == 1)
			{
				val = (TrickType)17;
			}
			if ((int)graffitiSpot.size == 2)
			{
				val = (TrickType)18;
			}
			if ((int)graffitiSpot.size == 3)
			{
				val = (TrickType)19;
			}
			GraffitiArt randomGraffitiArt = TagUtils.GetRandomGraffitiArt(graffitiSpot, __instance);
			__instance.DoTrick(val, randomGraffitiArt.title, 0);
			graffitiSpot.Paint((Crew)1, randomGraffitiArt, (Player)null);
			try
			{
				__instance.PlayVoice((AudioClipID)498, (VoicePriority)2, true);
			}
			catch (Exception)
			{
			}
			__instance.audioManager.PlaySfxGameplay((SfxCollectionID)13, (AudioClipID)559, 0f);
			__instance.RemoveGraffitiSlash();
			__instance.CreateGraffitiFinishEffect(((Component)graffitiSpot).transform, graffitiSpot.size);
			instance.SendPacket((Packet)new PlayerGraffitiFinisher((byte)graffitiSpot.size), (SendModes)2, (NetChannels)3);
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch("StartGraffitiMode")]
		private static void StartGraffitiMode_Postfix(Player __instance, GraffitiSpot graffitiSpot)
		{
			if (!__instance.inGraffitiGame)
			{
				return;
			}
			ClientController instance = ClientController.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.CurrentGraffitiGame = Object.FindFirstObjectByType<GraffitiGame>();
				if (instance.Connected)
				{
					instance.SendGenericEvent((GenericEvents)1, (SendModes)2);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("EndGraffitiMode")]
		private static void EndGraffitiMode_Postfix(Player __instance, GraffitiSpot graffitiSpot)
		{
			ClientController instance = ClientController.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.CurrentGraffitiGame = null;
				if (instance.Connected)
				{
					instance.SendGenericEvent((GenericEvents)1, (SendModes)2);
					instance.SendGenericEvent((GenericEvents)2, (SendModes)2);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("UpdateBoostpack")]
		private static bool UpdateBoostpack_Prefix(Player __instance)
		{
			if (MPUtility.IsMultiplayerPlayer(__instance))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("LateUpdateUIDisplay")]
		private static bool LateUpdateUIDisplay_Prefix(Player __instance)
		{
			if (__instance.isAI)
			{
				return true;
			}
			if ((Object)(object)ClientController.Instance == (Object)null)
			{
				return true;
			}
			Lobby currentLobby = ClientController.Instance.ClientLobbyManager.CurrentLobby;
			if (currentLobby == null)
			{
				return true;
			}
			if (!currentLobby.InGame)
			{
				return true;
			}
			if (currentLobby.CurrentGamemode is GraffitiRace)
			{
				__instance.GrafSpotVisualizationStop();
				__instance.StoryObjectVisualizationStop();
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch("OnLanded")]
		private static void OnLanded_Postfix(Player __instance)
		{
			if (!__instance.isAI)
			{
				PlayerComponent playerComponent = PlayerComponent.Get(__instance);
				if (!((Object)(object)playerComponent != (Object)null) || !playerComponent.HasPropDisguise)
				{
					ClientController.Instance.SendGenericEvent((GenericEvents)4, (SendModes)2);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("LandCombo")]
		private static void LandCombo_Postfix(Player __instance)
		{
			if (!__instance.IsComboing())
			{
				ProSkaterPlayer proSkaterPlayer = ProSkaterPlayer.Get(__instance);
				if ((Object)(object)proSkaterPlayer != (Object)null)
				{
					proSkaterPlayer.OnEndCombo();
				}
				if ((Object)(object)WorldHandler.instance.currentEncounter != (Object)null && WorldHandler.instance.currentEncounter is ProxyEncounter)
				{
					__instance.ClearMultipliersDone();
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("DropCombo")]
		private static bool DropCombo_Prefix(Player __instance)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.IsComboing())
			{
				return true;
			}
			ProSkaterPlayer proSkaterPlayer = ProSkaterPlayer.Get(__instance);
			if ((Object)(object)proSkaterPlayer != (Object)null)
			{
				proSkaterPlayer.OnEndCombo();
				__instance.baseScore = 0f;
				__instance.scoreMultiplier = 0f;
				__instance.lastScore = 0f;
				__instance.lastCornered = 0;
				__instance.ClearMultipliersDone();
				__instance.comboTimeOutTimer = 1f;
				__instance.currentTrickType = (TrickType)0;
				__instance.RefreshAirTricks();
				__instance.tricksInCombo = 0;
				__instance.RefreshAllDegrade();
				GameplayUI ui = __instance.ui;
				if ((Object)(object)ui != (Object)null)
				{
					ui.SetTrickingChargeBarActive(false);
				}
				WorldHandler.instance.AllowRedoGrafspots();
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("Awake")]
		private static void Awake_Prefix(Player __instance)
		{
			((Component)__instance).gameObject.AddComponent<PlayerComponent>();
		}
	}
	[HarmonyPatch(typeof(PlayerPhoneCameras))]
	internal static class PlayerPhoneCamerasPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("Awake")]
		private static bool Awake_Prefix(PlayerPhoneCameras __instance)
		{
			Player componentInParent = ((Component)__instance).GetComponentInParent<Player>();
			if ((Object)(object)componentInParent != (Object)null && MPUtility.IsMultiplayerPlayer(componentInParent))
			{
				((Behaviour)((Component)((Component)__instance).transform.Find("rearCamera")).GetComponent<Camera>()).enabled = false;
				((Behaviour)((Component)((Component)__instance).transform.Find("frontCamera")).GetComponent<Camera>()).enabled = false;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PublicToilet))]
	internal static class PublicToiletPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("DoSequence")]
		private static bool DoSequence_Prefix()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			if ((int)PlayerComponent.GetLocal().SpecialSkin != -1)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(SlideAbility))]
	internal static class SlideAbilityPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("OnStopAbility")]
		private static void OnStopAbility_Postfix(SlideAbility __instance)
		{
			if (((Ability)__instance).p.isAI)
			{
				return;
			}
			ProSkaterPlayer proSkaterPlayer = ProSkaterPlayer.Get(((Ability)__instance).p);
			if ((Object)(object)proSkaterPlayer != (Object)null)
			{
				if (((Ability)__instance).p.abilityTimer <= 0.125f)
				{
					proSkaterPlayer.PenalizeManual();
				}
				else
				{
					proSkaterPlayer.SoftResetManual();
				}
				proSkaterPlayer.ManualBalance.CurrentSensitivity += 0.0025f;
			}
		}
	}
	[HarmonyPatch(typeof(StageManager))]
	internal static class StageManagerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("IsPauseMenuAllowed")]
		private static bool IsPauseMenuAllowed_Prefix(ref bool __result)
		{
			if ((Object)(object)SpectatorController.Instance != (Object)null)
			{
				__result = false;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(StreetLife))]
	internal static class StreetLifePatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("OnTriggerStay")]
		private static bool OnTriggerStay(Collider other)
		{
			PropDisguiseController instance = PropDisguiseController.Instance;
			if ((Object)(object)instance != (Object)null && instance.FrozenProps)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(StyleSwitchMenu))]
	internal static class StyleSwitchMenuPatch
	{
		private static List<MenuTimelineButton> ExtraButtons = new List<MenuTimelineButton>();

		private static List<TMProLocalizationAddOn> ExtraTexts = new List<TMProLocalizationAddOn>();

		private static List<MPMoveStyleSkin> ExtraButtonSkins = new List<MPMoveStyleSkin>();

		private static MeshFilter[] _skateboardPreviewMeshes = null;

		private static TMProLocalizationAddOn _descriptionText = null;

		[HarmonyPrefix]
		[HarmonyPatch("StartMenu")]
		private static void StartMenu_Prefix(StyleSwitchMenu __instance, StyleSwitchBehaviour clipBehaviour)
		{
			__instance.clipBehaviour = clipBehaviour;
			StyleSwitchMenuEx styleSwitchMenuEx = StyleSwitchMenuEx.Get(__instance);
			if (styleSwitchMenuEx.OriginalMaterials == null)
			{
				styleSwitchMenuEx.OriginalMaterials = __instance.clipBehaviour.GetPreviewMaterials();
			}
			ApplyMaterials(styleSwitchMenuEx.OriginalMaterials, __instance);
		}

		private static void ApplyMaterials(Material[] materials, StyleSwitchMenu menu)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			GameObject val = null;
			foreach (PlayableBinding output in ((BaseMenuTimelineBehaviour)menu.clipBehaviour).director.playableAsset.outputs)
			{
				PlayableBinding current = output;
				if (((PlayableBinding)(ref current)).sourceObject is StyleSwitchTrack)
				{
					val = (GameObject)((BaseMenuTimelineBehaviour)menu.clipBehaviour).director.GetGenericBinding(((PlayableBinding)(ref current)).sourceObject);
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].sharedMaterials = materials;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Activate")]
		private static void Activate_Postfix(StyleSwitchMenu __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Invalid comparison between Unknown and I4
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Invalid comparison between Unknown and I4
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Invalid comparison between Unknown and I4
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Invalid comparison between Unknown and I4
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_0529: Unknown result type (might be due to invalid IL or missing references)
			//IL_052e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0558: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b9: Expected O, but got Unknown
			//IL_04eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f5: Expected O, but got Unknown
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			MPSaveData.MPCharacterData characterData = MPSaveData.Instance.GetCharacterData(currentPlayer.character);
			AUser user = Core.Instance.Platform.User;
			if (characterData.MPMoveStyleSkin != -1)
			{
				for (int i = 0; i < __instance.texts.Length; i++)
				{
					if (!user.GetUnlockableSaveDataFor((AUnlockable)(object)__instance.currentUnlockables[i]).isUnlocked)
					{
						__instance.texts[i].AssignAndUpdateText("???", (GroupOptions)0, Array.Empty<string>());
					}
					else
					{
						__instance.texts[i].AssignAndUpdateTextWithTags(__instance.currentUnlockables[i].Title, (GroupOptions)5, (string)null, (string)null, Array.Empty<string>());
					}
				}
			}
			_descriptionText = ((Component)((Component)__instance).transform.Find("DescriptionText")).GetComponent<TMProLocalizationAddOn>();
			StyleSwitchResetTexture[] array = Object.FindObjectsOfType<StyleSwitchResetTexture>();
			foreach (StyleSwitchResetTexture val in array)
			{
				if ((int)val.moveStyle == 2)
				{
					_skateboardPreviewMeshes = ((Component)val).GetComponentsInChildren<MeshFilter>();
					break;
				}
			}
			foreach (MenuTimelineButton extraButton in ExtraButtons)
			{
				if ((Object)(object)extraButton != (Object)null && (Object)(object)((Component)extraButton).gameObject != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)extraButton).gameObject);
				}
			}
			ExtraButtons.Clear();
			ExtraTexts.Clear();
			ExtraButtonSkins.Clear();
			MPSaveData instance = MPSaveData.Instance;
			foreach (KeyValuePair<int, MPUnlockable> item in MPUnlockManager.Instance.UnlockByID)
			{
				if (item.Value is MPMoveStyleSkin mPMoveStyleSkin && mPMoveStyleSkin.MoveStyle == __instance.moveStyleType && (!(mPMoveStyleSkin is MPBuiltInSkin) || (int)mPMoveStyleSkin.MoveStyle != 3 || PlayerComponent.GetLocal().HasCustomInlines) && (!(mPMoveStyleSkin is MPBuiltInSkin) || (int)mPMoveStyleSkin.MoveStyle != 2 || PlayerComponent.GetLocal().HasCustomSkateboard) && (!(mPMoveStyleSkin is MPBuiltInSkin) || (int)mPMoveStyleSkin.MoveStyle != 1 || PlayerComponent.GetLocal().HasCustomBmx) && (item.Key != Animator.StringToHash("goonieskateboard") || instance.ShouldDisplayGoonieBoard()))
				{
					ExtraButtonSkins.Add(mPMoveStyleSkin);
				}
			}
			Transform parent = __instance.firstButton.transform.parent;
			foreach (MPMoveStyleSkin extraButtonSkin in ExtraButtonSkins)
			{
				_ = extraButtonSkin;
				GameObject obj = Object.Instantiate<GameObject>(__instance.firstButton, parent);
				MenuTimelineButton component = obj.GetComponent<MenuTimelineButton>();
				TMProLocalizationAddOn componentInChildren = obj.GetComponentInChildren<TMProLocalizationAddOn>();
				ExtraButtons.Add(component);
				ExtraTexts.Add(componentInChildren);
			}
			if (ExtraButtons.Count <= 0)
			{
				return;
			}
			Navigation navigation = ((Selectable)__instance.buttons[__instance.buttons.Length - 1]).navigation;
			((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)ExtraButtons[0];
			((Selectable)__instance.buttons[__instance.buttons.Length - 1]).navigation = navigation;
			for (int k = 0; k < ExtraButtons.Count; k++)
			{
				MenuTimelineButton button = ExtraButtons[k];
				TMProLocalizationAddOn obj2 = ExtraTexts[k];
				MPMoveStyleSkin skin = ExtraButtonSkins[k];
				string text = null;
				if (skin.Identifier == characterData.MPMoveStyleSkin)
				{
					text = "<u>";
				}
				obj2.AssignAndUpdateTextWithTags(skin.Title, (GroupOptions)0, text, (string)null, Array.Empty<string>());
				MenuTimelineButton val2 = __instance.buttons[__instance.buttons.Length - 1];
				if (k > 0)
				{
					val2 = ExtraButtons[k - 1];
				}
				MenuTimelineButton val3 = __instance.cancelButton;
				if (k < ExtraButtons.Count - 1)
				{
					val3 = ExtraButtons[k + 1];
				}
				button.SetButtonVariables((OnSelectButtonAction)delegate
				{
					CustomSkinButtonSelected(__instance, button, skin);
				}, skin.UnlockedByDefault, (Button)(object)val2, (Button)(object)val3, __instance.normalGameFontType, __instance.selectedGameFontType, __instance.nonSelectableAlphaValue);
				((Selectable)button).interactable = true;
				((UnityEventBase)((Button)button).onClick).RemoveAllListeners();
				((UnityEvent)((Button)button).onClick).AddListener((UnityAction)delegate
				{
					CustomSkinButtonClicked(__instance, button, skin);
				});
				((Component)button).gameObject.SetActive(true);
			}
			Navigation navigation2 = ((Selectable)__instance.cancelButton).navigation;
			((Navigation)(ref navigation2)).selectOnUp = (Selectable)(object)ExtraButtons[ExtraButtons.Count - 1];
			((Selectable)__instance.cancelButton).navigation = navigation2;
		}

		[HarmonyPrefix]
		[HarmonyPatch("SkinButtonClicked")]
		private static void SkinButtonClicked_Prefix(StyleSwitchMenu __instance, MenuTimelineButton clickedButton, int skinIndex)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.IsTransitioning && !((Object)(object)__instance.buttonClicked != (Object)null) && clickedButton.canBeSelected)
			{
				Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
				PlayerComponent.Get(currentPlayer).ApplyMoveStyleSkin(0);
				MPSaveData.Instance.GetCharacterData(currentPlayer.character).MPMoveStyleSkin = -1;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SkinButtonSelected")]
		private static void SkinButtonSelected_Prefix(StyleSwitchMenu __instance, MenuTimelineButton clickedButton, int skinIndex)
		{
			ApplyMaterials(StyleSwitchMenuEx.Get(__instance).OriginalMaterials, __instance);
			Mesh sharedMesh = WorldHandler.instance.GetCurrentPlayer().MoveStylePropsPrefabs.skateboard.GetComponent<MeshFilter>().sharedMesh;
			MeshFilter[] skateboardPreviewMeshes = _skateboardPreviewMeshes;
			for (int i = 0; i < skateboardPreviewMeshes.Length; i++)
			{
				skateboardPreviewMeshes[i].sharedMesh = sharedMesh;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("SkinButtonSelected")]
		private static void SkinButtonSelected_Postfix(StyleSwitchMenu __instance, MenuTimelineButton clickedButton, int skinIndex)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			_descriptionText.AssignAndUpdateText("MOVESTYLE_DESCRIPTION", (GroupOptions)0, Array.Empty<string>());
			if (!((Object)(object)__instance == (Object)null) && (int)__instance.moveStyleType == 2)
			{
				Mesh sharedMesh = WorldHandler.instance.GetCurrentPlayer().MoveStylePropsPrefabs.skateboard.GetComponent<MeshFilter>().sharedMesh;
				MeshFilter[] skateboardPreviewMeshes = _skateboardPreviewMeshes;
				for (int i = 0; i < skateboardPreviewMeshes.Length; i++)
				{
					skateboardPreviewMeshes[i].sharedMesh = sharedMesh;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SkinButtonClicked")]
		private static void SkinButtonClicked_Prefix(StyleSwitchMenu __instance)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			PlayerComponent.Get(WorldHandler.instance.GetCurrentPlayer()).ApplyMoveStyleSkin(0);
			__instance.moveStyleMaterials = MoveStyleLoader.GetMoveStyleMaterials(WorldHandler.instance.GetCurrentPlayer(), __instance.moveStyleType);
		}

		private static void CustomSkinButtonClicked(StyleSwitchMenu menu, MenuTimelineButton clickedButton, MPMoveStyleSkin skin)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			if (menu.IsTransitioning || !((Object)(object)menu.buttonClicked == (Object)null))
			{
				return;
			}
			if (!clickedButton.canBeSelected)
			{
				if (menu.travelButtonCoroutine == null)
				{
					menu.travelButtonCoroutine = ((MonoBehaviour)menu).StartCoroutine(menu.CanNotPerformButtonActionAnimation(clickedButton));
				}
				return;
			}
			menu.buttonClicked = clickedButton;
			Core.Instance.AudioManager.PlaySfxUI((SfxCollectionID)23, (AudioClipID)547, 0f);
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			MPSaveData.Instance.GetCharacterData(currentPlayer.character).MPMoveStyleSkin = skin.Identifier;
			Core.Instance.SaveManager.SaveCurrentSaveSlot();
			skin.ApplyToPlayer(currentPlayer);
			((MonoBehaviour)menu).StartCoroutine(((BaseMenuTimelineBehaviour)menu.clipBehaviour).FlickerDelayedButtonPress(clickedButton, new UnityAction(((BaseMenuTimelineBehaviour)menu.clipBehaviour).ExitMenu)));
		}

		private static void CustomSkinButtonSelected(StyleSwitchMenu menu, MenuTimelineButton button, MPMoveStyleSkin skin)
		{
			if (menu.IsTransitioning || (Object)(object)menu.buttonClicked != (Object)null)
			{
				return;
			}
			ApplyMaterials(StyleSwitchMenuEx.Get(menu).OriginalMaterials, menu);
			if (!string.IsNullOrEmpty(skin.HowToUnlock))
			{
				_descriptionText.AssignAndUpdateText(skin.HowToUnlock, (GroupOptions)0, Array.Empty<string>());
			}
			else
			{
				_descriptionText.AssignAndUpdateText("MOVESTYLE_DESCRIPTION", (GroupOptions)0, Array.Empty<string>());
			}
			if ((Object)(object)skin.Texture != (Object)null)
			{
				if (menu.previewMaterials != null)
				{
					Material[] previewMaterials = menu.previewMaterials;
					for (int i = 0; i < previewMaterials.Length; i++)
					{
						_ = previewMaterials[i];
						for (int j = 0; j < menu.previewMaterials.Length; j++)
						{
							menu.previewMaterials[j].mainTexture = skin.Texture;
						}
					}
				}
			}
			else if (skin.Materials != null)
			{
				ApplyMaterials(skin.Materials, menu);
			}
			if (skin is MPSkateboardSkin mPSkateboardSkin)
			{
				Mesh val = mPSkateboardSkin.SkateboardMesh;
				if ((Object)(object)val == (Object)null)
				{
					val = WorldHandler.instance.GetCurrentPlayer().MoveStylePropsPrefabs.skateboard.GetComponent<MeshFilter>().sharedMesh;
				}
				MeshFilter[] skateboardPreviewMeshes = _skateboardPreviewMeshes;
				for (int i = 0; i < skateboardPreviewMeshes.Length; i++)
				{
					skateboardPreviewMeshes[i].sharedMesh = val;
				}
			}
		}
	}
	[HarmonyPatch(typeof(UIManager))]
	internal static class UIManagerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("ShowPauseMenu")]
		private static bool ShowPauseMenu_Prefix()
		{
			if (MPUtility.AnyMenusOpen())
			{
				return false;
			}
			Lobby currentLobby = ClientController.Instance.ClientLobbyManager.CurrentLobby;
			if (currentLobby != null && currentLobby.InGame)
			{
				return false;
			}
			return true;
		}
	}
}
namespace BombRushMP.Plugin.OfflineInterface
{
	public class LocalServerDatabase : IServerDatabase
	{
		public const string OfflineAuthKey = "Offline";

		public BannedUsers BannedUsers { get; } = new BannedUsers();


		public AuthKeys AuthKeys { get; } = new AuthKeys();


		public LocalServerDatabase(string adminKey)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			Dictionary<string, AuthUser> users = AuthKeys.Users;
			AuthUser val = new AuthUser();
			val.UserKind = (UserKinds)2;
			val.Badges = new int[1];
			users[adminKey] = val;
		}

		public void Load()
		{
		}

		public void Save()
		{
		}

		public void LogChatMessage(string message, int stage)
		{
		}
	}
	public class OfflineClient : INetClient
	{
		public OfflineServer Server => ServerController.Instance.Server.Server as OfflineServer;

		public bool IsConnected => Server.LocalConnected;

		public EventHandler Connected { get; set; }

		public EventHandler<MessageReceivedEventArgs> MessageReceived { get; set; }

		public EventHandler<DisconnectedEventArgs> Disconnected { get; set; }

		public EventHandler<ConnectionFailedEventArgs> ConnectionFailed { get; set; }

		public EventHandler<ushort> ClientDisconnected { get; set; }

		public bool Connect(string address, int port)
		{
			Server.ConnectLocal();
			Connected?.Invoke(this, null);
			return true;
		}

		public void Disconnect()
		{
			Server.DisconnectLocal();
		}

		public void Send(IMessage message)
		{
			new OfflineConnection(server: true).Send(message);
		}

		public void Update()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			List<OfflineMessage> list;
			lock (OfflineInterface.ServerToClientMessages)
			{
				list = new List<OfflineMessage>(OfflineInterface.ServerToClientMessages);
				OfflineInterface.ServerToClientMessages.Clear();
			}
			foreach (OfflineMessage item in list)
			{
				try
				{
					MessageReceived?.Invoke(this, new MessageReceivedEventArgs(item.PacketId, (IMessage)(object)item, (INetConnection)(object)new OfflineConnection(server: true)));
				}
				catch (Exception ex)
				{
					Debug.LogError((object)ex);
				}
			}
		}

		public override string ToString()
		{
			return "Client";
		}
	}
	public class OfflineConnection : INetConnection
	{
		private bool _server;

		public bool CanQualityDisconnect { get; set; }

		public ushort Id => (!_server) ? ((ushort)1) : ((ushort)0);

		public string Address => "Local";

		public OfflineConnection(bool server)
		{
			_server = server;
		}

		public void Send(IMessage message)
		{
			if (_server)
			{
				lock (OfflineInterface.ClientToServerMessages)
				{
					OfflineInterface.ClientToServerMessages.Add(message as OfflineMessage);
					return;
				}
			}
			lock (OfflineInterface.ServerToClientMessages)
			{
				OfflineInterface.ServerToClientMessages.Add(message as OfflineMessage);
			}
		}

		public override string ToString()
		{
			if (!_server)
			{
				return "Client";
			}
			return "Server";
		}
	}
	public class OfflineInterface : INetworkingInterface
	{
		public static List<OfflineMessage> ClientToServerMessages = new List<OfflineMessage>();

		public static List<OfflineMessage> ServerToClientMessages = new List<OfflineMessage>();

		public const ushort ClientId = 1;

		public const ushort ServerId = 0;

		public int MaxPayloadSize { get; set; }

		public INetClient CreateClient()
		{
			return (INetClient)(object)new OfflineClient();
		}

		public IMessage CreateMessage(SendModes sendMode, NetChannels channel, Enum packetId)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return (IMessage)(object)new OfflineMessage(Convert.ToUInt16(packetId), channel);
		}

		public INetServer CreateServer()
		{
			return (INetServer)(object)new OfflineServer();
		}

		public override string ToString()
		{
			return "Offline";
		}
	}
	public class OfflineMessage : IMessage
	{
		public ushort PacketId;

		private byte[] _data;

		public OfflineMessage(ushort packetId, NetChannels channel = 0)
		{
			PacketId = packetId;
		}

		public OfflineMessage(ushort packetId, byte[] data, NetChannels channel = 0)
		{
			PacketId = packetId;
			_data = data;
		}

		public IMessage Add(byte[] data)
		{
			_data = data;
			return (IMessage)(object)this;
		}

		public byte[] GetBytes()
		{
			return _data;
		}
	}
	public class OfflineServer : INetServer
	{
		public volatile bool LocalConnected;

		public EventHandler<MessageReceivedEventArgs> MessageReceived { get; set; }

		public EventHandler<ServerDisconnectedEventArgs> ClientDisconnected { get; set; }

		public EventHandler<ServerConnectedEventArgs> ClientConnected { get; set; }

		public int TimeoutTime
		{
			set
			{
			}
		}

		public void DisconnectClient(ushort id)
		{
			DisconnectLocal();
		}

		public void DisconnectClient(INetConnection client)
		{
			DisconnectLocal();
		}

		public void Start(ushort port, ushort maxPlayers)
		{
		}

		public void Stop()
		{
			DisconnectLocal();
		}

		public void ConnectLocal()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (!LocalConnected)
			{
				LocalConnected = true;
				ClientConnected?.Invoke(this, new ServerConnectedEventArgs((INetConnection)(object)new OfflineConnection(server: false)));
			}
		}

		public void DisconnectLocal()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			if (LocalConnected)
			{
				LocalConnected = false;
				ClientDisconnected?.Invoke(this, new ServerDisconnectedEventArgs((INetConnection)(object)new OfflineConnection(server: false), "Disconnect"));
			}
		}

		public void Update()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			List<OfflineMessage> list;
			lock (OfflineInterface.ClientToServerMessages)
			{
				list = new List<OfflineMessage>(OfflineInterface.ClientToServerMessages);
				OfflineInterface.ClientToServerMessages.Clear();
			}
			foreach (OfflineMessage item in list)
			{
				try
				{
					MessageReceived?.Invoke(this, new MessageReceivedEventArgs(item.PacketId, (IMessage)(object)item, (INetConnection)(object)new OfflineConnection(server: false)));
				}
				catch (Exception ex)
				{
					Debug.LogError((object)ex);
				}
			}
		}

		public override string ToString()
		{
			return "Server";
		}
	}
}
namespace BombRushMP.Plugin.LocalServer
{
	public class ServerController
	{
		public BRCServer Server;

		private int _port;

		public static ServerController Instance { get; private set; }

		private INetworkingInterface NetworkingInterface => NetworkingEnvironment.NetworkingInterface;

		public ServerController(int port, float tickRate, ushort maxPlayers, bool offline, LocalServerDatabase db)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			Instance = this;
			Server = new BRCServer(port, maxPlayers, tickRate, (IServerDatabase)(object)db);
			Thread thread = new Thread(Update);
			thread.IsBackground = true;
			thread.Start();
		}

		private void Update()
		{
			while (true)
			{
				Server.Update();
			}
		}
	}
}
namespace BombRushMP.Plugin.Gamemodes
{
	public class Gamemode
	{
		public enum PlayerSort
		{
			Score,
			Wins
		}

		private static int SettingCountdownID = Animator.StringToHash("Countdown");

		private static int SettingTPToSpawnOnEnd = Animator.StringToHash("TPToSpawnOnEnd");

		private const int MinCountdown = 3;

		private const int MaxCountdown = 10;

		public bool TeamBased;

		public int DefaultCountdown = 3;

		public bool CanChangeCountdown = true;

		public MinimapOverrideModes MinimapOverrideMode;

		public Lobby Lobby;

		public GamemodeSettings Settings;

		protected ClientController ClientController;

		protected ClientLobbyManager ClientLobbyManager;

		protected Vector3 SpawnPos = Vector3.zero;

		protected Quaternion SpawnRot = Quaternion.identity;

		public bool InGame { get; private set; }

		protected int Countdown
		{
			get
			{
				if (!CanChangeCountdown)
				{
					return DefaultCountdown;
				}
				return Settings.SettingByID[SettingCountdownID].Value;
			}
		}

		protected bool TeleportToSpawnOnEnd => (Settings.SettingByID[SettingTPToSpawnOnEnd] as ToggleGamemodeSetting).IsOn;

		protected GamemodeIDs GamemodeId => Lobby.LobbyState.Gamemode;

		public Gamemode()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			ClientController = ClientController.Instance;
			ClientLobbyManager = ClientController.ClientLobbyManager;
		}

		protected void SetSpawnLocation()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			SpawnPos = ((Component)currentPlayer).transform.position;
			SpawnRot = ((Component)currentPlayer).transform.rotation;
			currentPlayer.saveLocation = currentPlayer.GenerateSafeLocation();
		}

		public virtual void OnStart()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			InGame = true;
			MPUtility.SetUpPlayerForGameStateUpdate();
			MPUtility.BreakAllBreakables();
			MPUtility.ResetProps();
			Settings = GamemodeFactory.ParseGamemodeSettings(Lobby.LobbyState.Gamemode, Lobby.LobbyState.GamemodeSettings);
			LobbyUI.Instance.UpdateUI();
			Core.Instance.AudioManager.PlaySfxUI((SfxCollectionID)23, (AudioClipID)547, 0f);
			if (Lobby.LobbyState.HostId == ClientController.Instance.LocalID)
			{
				ClientController.SendPacket((Packet)new ClientGamemodeCountdown((ushort)Countdown), (SendModes)1, (NetChannels)1);
			}
			SetSpawnLocation();
		}

		protected int GetTeamAmount()
		{
			HashSet<byte> hashSet = new HashSet<byte>();
			foreach (KeyValuePair<ushort, LobbyPlayer> player in Lobby.LobbyState.Players)
			{
				hashSet.Add(player.Value.Team);
			}
			return hashSet.Count;
		}

		public virtual void OnEnd(bool cancelled)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: 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_00ef: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			MPSaveData instance = MPSaveData.Instance;
			GamemodeIDs gamemode = Lobby.LobbyState.Gamemode;
			InGame = false;
			MPUtility.SetUpPlayerForGameStateUpdate();
			LobbyUI.Instance.UpdateUI();
			if (!cancelled)
			{
				Core.Instance.AudioManager.PlaySfxUI((SfxCollectionID)19, (AudioClipID)680, 0f);
				if (!TeamBased)
				{
					if (Lobby.LobbyState.Players.Count > 1)
					{
						instance.Stats.IncreaseGamemodesPlayed(gamemode);
						if (GetWinningPlayers().Contains(ClientController.LocalID))
						{
							instance.Stats.IncreaseGamemodesWon(gamemode);
						}
					}
					else
					{
						instance.Stats.IncreaseGamemodesPlayedAlone(gamemode);
					}
				}
				else if (GetTeamAmount() > 1)
				{
					instance.Stats.IncreaseGamemodesPlayed(gamemode);
					if (GetWinningPlayers().Contains(ClientController.LocalID))
					{
						instance.Stats.IncreaseGamemodesWon(gamemode);
					}
				}
				else
				{
					instance.Stats.IncreaseGamemodesPlayedAlone(gamemode);
				}
				bool flag = false;
				if (!AmIElite())
				{
					if (AnyEliteInLobby())
					{
						instance.Stats.ElitesPlayedAgainst++;
						if (WonAgainstElite())
						{
							instance.Stats.ElitesBeaten++;
							if (!instance.ShouldDisplayGoonieBoard())
							{
								ChatUI.Instance.AddMessage("<color=yellow>You've unlocked the Goonie skateboard skin for beating a Freesoul Elite!</color>");
								instance.UnlockGoonieBoard();
								flag = true;
							}
						}
					}
					if (!instance.ShouldDisplayGoonieBoard() && !flag && WonAgainstPlayerWithSpecialUnlock())
					{
						ChatUI.Instance.AddMessage("<color=yellow>You've unlocked the Goonie skateboard skin for beating a player who unlocked it!</color>");
						instance.UnlockGoonieBoard();
						flag = true;
					}
				}
				Core.Instance.SaveManager.SaveCurrentSaveSlot();
			}
			else
			{
				Core.Instance.AudioManager.PlaySfxUI((SfxCollectionID)23, (AudioClipID)550, 0f);
			}
			if (TeleportToSpawnOnEnd)
			{
				MPUtility.PlaceCurrentPlayer(SpawnPos, SpawnRot);
			}
		}

		private bool AmIElite()
		{
			AuthUser localUser = ClientController.Instance.GetLocalUser();
			if (localUser == null)
			{
				return false;
			}
			return localUser.HasTag("elite");
		}

		private bool AnyEliteInOppositeTeam()
		{
			byte team = Lobby.LobbyState.Players[ClientController.LocalID].Team;
			foreach (KeyValuePair<ushort, LobbyPlayer> player in Lobby.LobbyState.Players)
			{
				if (ClientController.GetUser(player.Key).HasTag("elite") && player.Value.Team != team)
				{
					return true;
				}
			}
			return false;
		}

		private bool AnyEliteInLobby()
		{
			foreach (KeyValuePair<ushort, LobbyPlayer> player in Lobby.LobbyState.Players)
			{
				if (ClientController.GetUser(player.Key).HasTag("elite"))
				{
					return true;
				}
			}
			return false;
		}

		protected List<ushort> GetWinningPlayers()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!TeamBased)
			{
				return new List<ushort> { Lobby.GetHighestScoringPlayer().Id };
			}
			List<ushort> list = new List<ushort>();
			int num = -1;
			float num2 = 0f;
			Team[] teams = GamemodeFactory.GetTeams(GamemodeId);
			for (int i = 0; i < teams.Length; i++)
			{
				float scoreForTeam = Lobby.LobbyState.GetScoreForTeam((byte)i);
				if (num == -1)
				{
					num = i;
					num2 = scoreForTeam;
				}
				else if (scoreForTeam > num2)
				{
					num = i;
					num2 = scoreForTeam;
				}
			}
			foreach (KeyValuePair<ushort, LobbyPlayer> player in Lobby.LobbyState.Players)
			{
				if (player.Value.Team == num)
				{
					list.Add(player.Key);
				}
			}
			return list;
		}

		private bool AnyPlayerWithSpecialUnlockInOppositeTeam()
		{
			byte team = Lobby.LobbyState.Players[ClientController.LocalID].Team;
			foreach (KeyValuePair<ushort, LobbyPlayer> player in Lobby.LobbyState.Players)
			{
				if (ClientController.Players[player.Key].ClientState.HasSpecialUnlock && player.Value.Team != team)
				{
					return true;
				}
			}
			return false;
		}

		private bool WonAgainstPlayerWithSpecialUnlock()
		{
			if (Lobby == null)
			{
				return false;
			}
			if (Lobby.LobbyState == null)
			{
				return false;
			}
			if (Lobby.LobbyState.Players == null)
			{
				return false;
			}
			if (TeamBased)
			{
				if (AnyPlayerWithSpecialUnlockInOppositeTeam() && GetWinningPlayers().Contains(ClientController.LocalID))
				{
					return true;
				}
				return false;
			}
			float score = Lobby.LobbyState.Players[ClientController.LocalID].Score;
			foreach (KeyValuePair<ushort, LobbyPlayer> player in Lobby.LobbyState.Players)
			{
				if (ClientController.Players[player.Key].ClientState.HasSpecialUnlock && player.Value.Score < score)
				{
					return true;
				}
			}
			return false;
		}

		private bool WonAgainstElite()
		{
			if (Lobby == null)
			{
				return false;
			}
			if (Lobby.LobbyState == null)
			{
				return false;
			}
			if (Lobby.LobbyState.Players == null)
			{
				return false;
			}
			LobbyPlayer highestScoringPlayer = Lobby.GetHighestScoringPlayer();
			AuthUser user = ClientController.GetUser(highestScoringPlayer.Id);
			if (user == null)
			{
				return false;
			}
			if (user.HasTag("elite"))
			{
				return false;
			}
			if (TeamBased)
			{
				if (AnyEliteInOppositeTeam() && GetWinningPlayers().Contains(ClientController.LocalID))
				{
					return true;
				}
				return false;
			}
			bool flag = false;
			float num = 0f;
			foreach (KeyValuePair<ushort, LobbyPlayer> player in Lobby.LobbyState.Players)
			{
				user = ClientController.GetUser(player.Key);
				if (user != null && user.HasTag("elite"))
				{
					flag = true;
					if (player.Value.Score > num)
					{
						num = player.Value.Score;
					}
				}
			}
			if (!flag)
			{
				return false;
			}
			if (!Lobby.LobbyState.Players.TryGetValue(ClientController.LocalID, out var value))
			{
				return false;
			}
			if (value.Score > num)
			{
				return true;
			}
			return false;
		}

		public virtual void OnUpdate_InGame()
		{
		}

		public virtual void OnTick_InGame()
		{
		}

		public virtual void OnPacketReceived_InGame(Packets packetId, Packet packet)
		{
		}

		public virtual GamemodeSettings GetDefaultSettings()
		{
			GamemodeSettings gamemodeSettings = new GamemodeSettings();
			if (CanChangeCountdown)
			{
				gamemodeSettings.SettingByID[SettingCountdownID] = new GamemodeSetting("Countdown (Seconds)", DefaultCountdown, 3, 10);
			}
			gamemodeSettings.SettingByID[SettingTPToSpawnOnEnd] = new ToggleGamemodeSetting("Teleport to Spawn On End", on: false);
			return gamemodeSettings;
		}
	}
	public static class GamemodeFactory
	{
		private static Team[] _defaultTeams = new Team[4]
		{
			new Team("Red Team", Color.red),
			new Team("Blue Team", Color.blue),
			new Team("Yellow Team", Color.yellow),
			new Team("Green Team", Color.green)
		};

		private static Team[] _propHuntTeams = new Team[2]
		{
			new Team("Hunters", Color.red),
			new Team("Props", Color.green)
		};

		private static Dictionary<GamemodeIDs, Type> Gamemodes = new Dictionary<GamemodeIDs, Type>
		{
			{
				(GamemodeIDs)0,
				typeof(ScoreBattle)
			},
			{
				(GamemodeIDs)1,
				typeof(GraffitiRace)
			},
			{
				(GamemodeIDs)2,
				typeof(TeamGraffitiRace)
			},
			{
				(GamemodeIDs)3,
				typeof(ProSkaterScoreBattle)
			},
			{
				(GamemodeIDs)4,
				typeof(TeamScoreBattle)
			},
			{
				(GamemodeIDs)5,
				typeof(TeamProSkaterScoreBattle)
			},
			{
				(GamemodeIDs)6,
				typeof(PropHunt)
			}
		};

		private static Dictionary<GamemodeIDs, string> GamemodeNames = new Dictionary<GamemodeIDs, string>
		{
			{
				(GamemodeIDs)0,
				"Score Battle"
			},
			{
				(GamemodeIDs)1,
				"Graffiti Race"
			},
			{
				(GamemodeIDs)2,
				"Crew Graffiti Race"
			},
			{
				(GamemodeIDs)3,
				"Pro Skater Score Battle"
			},
			{
				(GamemodeIDs)4,
				"Crew Score Battle"
			},
			{
				(GamemodeIDs)5,
				"Crew Pro Skater Score Battle"
			},
			{
				(GamemodeIDs)6,
				"Prop Hunt"
			}
		};

		public static bool HasWins(GamemodeIDs gamemodeId)
		{
			//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_0007: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			if ((int)gamemodeId == 0)
			{
				return true;
			}
			if ((int)gamemodeId == 1)
			{
				return true;
			}
			if ((int)gamemodeId == 3)
			{
				return true;
			}
			return false;
		}

		public static bool IsExclusive(GamemodeIDs gamemodeId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)gamemodeId == 6)
			{
				return true;
			}
			return false;
		}

		public static Team[] GetTeams(GamemodeIDs gamemodeId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)gamemodeId == 6)
			{
				return _propHuntTeams;
			}
			return _defaultTeams;
		}

		public static bool IsRegistered(GamemodeIDs gameModeID)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return Gamemodes.ContainsKey(gameModeID);
		}

		public static Gamemode GetGamemode(GamemodeIDs gameModeID)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!Gamemodes.TryGetValue(gameModeID, out var value))
			{
				Debug.LogWarning((object)$"Unknown gamemode '{gameModeID}', falling back to Score Battle.");
				value = Gamemodes[(GamemodeIDs)0];
			}
			return Activator.CreateInstance(value) as Gamemode;
		}

		public static GamemodeSettings GetGamemodeSettings(GamemodeIDs gameModeID)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetGamemode(gameModeID).GetDefaultSettings();
		}

		public static GamemodeSettings ParseGamemodeSettings(GamemodeIDs gameModeID, byte[] serializedSettings)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			GamemodeSettings defaultSettings = GetGamemode(gameModeID).GetDefaultSettings();
			if (serializedSettings.Length != 0)
			{
				using MemoryStream input = new MemoryStream(serializedSettings);
				using BinaryReader reader = new BinaryReader(input);
				defaultSettings.Read(reader);
			}
			return defaultSettings;
		}

		public static string GetGamemodeName(GamemodeIDs gameModeID)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (!GamemodeNames.TryGetValue(gameModeID, out var value))
			{
				return "Unknown";
			}
			return value;
		}
	}
	public class GamemodeSetting
	{
		public string Label;

		public int Value;

		public int MinValue;

		public int MaxValue;

		public int AddSteps = 1;

		public Type EnumType;

		public Func<Dictionary<int, GamemodeSetting>, bool> OnCheckVisibility;

		public GamemodeSetting(string label, int value, int min, int max, int addSteps = 1)
		{
			Label = label;
			Value = value;
			MinValue = min;
			MaxValue = max;
			AddSteps = addSteps;
		}

		public GamemodeSetting(string label, Enum value, int addSteps = 1)
		{
			Label = label;
			Value = Convert.ToInt32(value);
			Array values = Enum.GetValues(value.GetType());
			int num = int.MaxValue;
			int num2 = int.MinValue;
			foreach (object item in values)
			{
				int num3 = Convert.ToInt32(item);
				if (num3 <= num)
				{
					num = num3;
				}
				if (num3 >= num2)
				{
					num2 = num3;
				}
			}
			MinValue = num;
			MaxValue = num2;
			AddSteps = addSteps;
			EnumType = value.GetType();
		}

		public override string ToString()
		{
			if (EnumType != null)
			{
				return Label + " = " + Enum.GetName(EnumType, Value).Replace('_', ' ');
			}
			return $"{Label} = {Value}";
		}

		public virtual void Next()
		{
			int value = Value;
			Value += AddSteps;
			if (Value > MaxValue)
			{
				if (value != MaxValue)
				{
					Value = MaxValue;
				}
				else
				{
					Value = MinValue;
				}
			}
		}

		public virtual void Write(BinaryWriter writer)
		{
			writer.Write(Value);
		}

		public virtual void Read(BinaryReader reader)
		{
			Value = reader.ReadInt32();
		}
	}
	public class GamemodeSettings
	{
		public Dictionary<int, GamemodeSetting> SettingByID = new Dictionary<int, GamemodeSetting>();

		public SavedGamemodeSettings ToSaved()
		{
			SavedGamemodeSettings savedGamemodeSettings = new SavedGamemodeSettings();
			foreach (KeyValuePair<int, GamemodeSetting> item in SettingByID)
			{
				savedGamemodeSettings.ValueByID[item.Key] = item.Value.Value;
			}
			return savedGamemodeSettings;
		}

		public void ApplySaved(SavedGamemodeSettings savedSettings)
		{
			foreach (KeyValuePair<int, GamemodeSetting> item in SettingByID)
			{
				if (savedSettings.ValueByID.TryGetValue(item.Key, out var value))
				{
					int num = value;
					if (num > item.Value.MaxValue || num < item.Value.MinValue)
					{
						num = item.Value.Value;
					}
					item.Value.Value = num;
				}
			}
		}

		public string GetDisplayString(bool host, bool inGame)
		{
			string text = "";
			foreach (GamemodeSetting value in SettingByID.Values)
			{
				if (value.OnCheckVisibility == null || value.OnCheckVisibility(SettingByID))
				{
					text = text + value.ToString() + "\n";
				}
			}
			if (!inGame)
			{
				if (!string.IsNullOrEmpty(text))
				{
					text += "\n";
				}
				text = ((!host) ? (text + "Use the Lobby menu in the Multiplayer phone app to toggle Ready or switch teams.") : (text + "Use the Lobby menu in the Multiplayer phone app to start the game, change the mode or switch teams."));
			}
			return text;
		}

		public void Write(BinaryWriter writer)
		{
			writer.Write(SettingByID.Count);
			foreach (KeyValuePair<int, GamemodeSetting> item in SettingByID)
			{
				writer.Write(item.Key);
				item.Value.Write(writer);
			}
		}

		public void Read(BinaryReader reader)
		{
			int num = reader.ReadInt32();
			for (int i = 0; i < num; i++)
			{
				int key = reader.ReadInt32();
				if (SettingByID.TryGetValue(key, out var value))
				{
					value.Read(reader);
					continue;
				}
				break;
			}
		}
	}
	public class GraffitiRace : Gamemode
	{
		public enum SpawnMode
		{
			Automatic,
			At_Host,
			Current_Positions
		}

		public enum MoveStyleMode
		{
			Force_MoveStyle,
			Force_On_Foot,
			Current
		}

		public enum States
		{
			Countdown,
			Main,
			Finished
		}

		private enum FetchingStates
		{
			None,
			Started,
			Finished
		}

		private static int SettingMoveStyleID = Animator.StringToHash("MoveStyle");

		private static int SettingSpawnModeID = Animator.StringToHash("SpawnMode");

		private static int SettingQuickGraffitiID = Animator.StringToHash("QuickGraffiti");

		private static int SettingAutoGraffitiID = Animator.StringToHash("AutoGraffiti");

		private static int SettingGraffitiAmountID = Animator.StringToHash("GraffitiAmount");

		private static int SettingSingleGraffitiID = Animator.StringToHash("SingleGraffiti");

		private const int DefaultGraffiti = 10;

		private const int MinGraffiti = 5;

		private const int MaxGraffiti = 70;

		private const int GraffitiSteps = 5;

		private const float DistanceOffWall = 3f;

		private List<StageChunk> _offStageChunks = new List<StageChunk>();

		public int Score;

		private States _state;

		private FetchingStates _fetchingState;

		private float _countdownTimer;

		private WorldHandler _worldHandler;

		private Dictionary<GraffitiSpot, GraffitiSpotProgress> _originalProgress = new Dictionary<GraffitiSpot, GraffitiSpotProgress>();

		private HashSet<GraffitiSpot> _otherSpots = new HashSet<GraffitiSpot>();

		private UIScreenIndicators _indicators;

		private Dictionary<GraffitiSpot, MapPin> _mapPins = new Dictionary<GraffitiSpot, MapPin>();

		public bool QuickGraffitiEnabled => (Settings.SettingByID[SettingQuickGraffitiID] as ToggleGamemodeSetting).IsOn;

		public bool AutoGraffitiEnabled => (Settings.SettingByID[SettingAutoGraffitiID] as ToggleGamemodeSetting).IsOn;

		private void RestoreStageChunks()
		{
			foreach (StageChunk offStageChunk in _offStageChunks)
			{
				((Component)offStageChunk).gameObject.SetActive(false);
			}
			_offStageChunks.Clear();
		}

		private void TurnOnAllStageChunks()
		{
			_offStageChunks.Clear();
			foreach (StageChunk stageChunk in WorldHandler.instance.SceneObjectsRegister.stageChunks)
			{
				if (!((Component)stageChunk).gameObject.activeSelf)
				{
					_offStageChunks.Add(stageChunk);
					((Component)stageChunk).gameObject.SetActive(true);
				}
			}
		}

		public GraffitiRace()
		{
			_worldHandler = WorldHandler.instance;
			MinimapOverrideMode = MinimapOverrideModes.ForceOn;
		}

		public override void OnPacketReceived_InGame(Packets packetId, Packet packet)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			Player currentPlayer = _worldHandler.GetCurrentPlayer();
			if ((int)packetId <= 22)
			{
				if ((int)packetId != 19)
				{
					if ((int)packetId == 22)
					{
						ClientGraffitiRaceGSpots packet2 = (ClientGraffitiRaceGSpots)packet;
						OnReceive_GraffitiRaceData(packet2);
					}
				}
				else
				{
					_state = States.Main;
					currentPlayer.userInputEnabled = true;
					_countdownTimer = 0f;
				}
			}
			else if ((int)packetId != 36)
			{
				if ((int)packetId == 43)
				{
					OnReceive_TeamGraffitiRaceScore((ServerTeamGraffRaceScore)packet);
				}
			}
			else
			{
				ClientGraffitiRaceStart packet3 = (ClientGraffitiRaceStart)packet;
				OnReceive_GraffitiStart(packet3);
			}
		}

		public override void OnStart()
		{
			base.OnStart();
			_fetchingState = FetchingStates.None;
			_indicators = UIScreenIndicators.Create();
			TimerUI.Instance.Activate();
			if (ClientController.LocalID == Lobby.LobbyState.HostId)
			{
				OnStart_Host();
			}
			Player currentPlayer = _worldHandler.GetCurrentPlayer();
			currentPlayer.boostCharge = currentPlayer.maxBoostCharge;
			currentPlayer.userInputEnabled = false;
			if (Settings.SettingByID[SettingMoveStyleID].Value == 0)
			{
				currentPlayer.SwitchToEquippedMovestyle(true, false, true, true);
			}
			else if (Settings.SettingByID[SettingMoveStyleID].Value == 1)
			{
				currentPlayer.SwitchToEquippedMovestyle(false, false, true, true);
			}
		}

		public override void OnUpdate_InGame()
		{
			TimerUI instance = TimerUI.Instance;
			switch (_state)
			{
			case States.Countdown:
			{
				int num2 = Mathf.FloorToInt(_countdownTimer);
				instance.SetText(Mathf.Max(1, base.Countdown - num2).ToString());
				break;
			}
			case States.Main:
			{
				int num = Score;
				if (TeamBased)
				{
					num = (int)Lobby.LobbyState.GetScoreForTeam(Lobby.LobbyState.Players[ClientController.LocalID].Team);
				}
				string text = $"{num}/{_originalProgress.Count}";
				if (MPSettings.Instance.GraceTimer)
				{
					text = text + "\n" + TimerUI.GetTimeString(_countdownTimer);
				}
				instance.SetText(text);
				break;
			}
			}
			_countdownTimer += Time.deltaTime;
		}

		public bool IsRaceGraffitiSpot(GraffitiSpot grafSpot)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			if (_originalProgress.ContainsKey(grafSpot))
			{
				return (int)grafSpot.topCrew == 0;
			}
			return false;
		}

		public void MarkGraffitiSpotDone(GraffitiSpot grafSpot)
		{
			Mapcontroller instance = Mapcontroller.Instance;
			_indicators.RemoveIndicator(((Component)grafSpot).transform);
			if (_mapPins.TryGetValue(grafSpot, out var value))
			{
				instance.m_MapPins.Remove(value);
				value.isMapPinValid = false;
				value.DisableMapPinGameObject();
				Object.Destroy((Object)(object)((Component)value).gameObject);
				_mapPins.Remove(grafSpot);
			}
		}

		public void AddScore(GraffitiSpot gSpot)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			if (!TeamBased)
			{
				Score++;
				ClientGamemodeScore packet = new ClientGamemodeScore((float)Score);
				ClientController.SendPacket((Packet)(object)packet, (SendModes)1, (NetChannels)1);
			}
			else
			{
				ClientTeamGraffRaceScore packet2 = new ClientTeamGraffRaceScore(Compression.HashString(((AProgressable)gSpot).Uid));
				ClientController.SendPacket((Packet)(object)packet2, (SendModes)1, (NetChannels)1);
			}
		}

		public override void OnEnd(bool cancelled)
		{
			base.OnEnd(cancelled);
			_fetchingState = FetchingStates.None;
			Mapcontroller instance = Mapcontroller.Instance;
			foreach (MapPin value in _mapPins.Values)
			{
				if (!((Object)(object)value == (Object)null))
				{
					if ((Object)(object)instance != (Object)null)
					{
						instance.m_MapPins.Remove(value);
					}
					value.isMapPinValid = false;
					value.DisableMapPinGameObject();
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			if ((Object)(object)_indicators != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_indicators).gameObject);
			}
			foreach (GraffitiSpot otherSpot in _otherSpots)
			{
				if (!((Object)(object)otherSpot == (Object)null))
				{
					((Component)otherSpot).gameObject.SetActive(true);
				}
			}
			foreach (KeyValuePair<GraffitiSpot, GraffitiSpotProgress> item in _originalProgress)
			{
				if (!((Object)(object)item.Key == (Object)null))
				{
					((AProgressable)item.Key).progressableData = (ProgressableData)(object)item.Value;
					((AProgressable)item.Key).ReadFromData();
				}
			}
			if (_state == States.Countdown)
			{
				Player currentPlayer = _worldHandler.GetCurrentPlayer();
				if ((Object)(object)currentPlayer != (Object)null)
				{
					currentPlayer.userInputEnabled = true;
				}
			}
			TimerUI instance2 = TimerUI.Instance;
			if ((Object)(object)instance2 != (Object)null)
			{
				instance2.DeactivateDelayed();
			}
		}

		private GraffitiSpot GetGraffitiSpotByHash(int hash)
		{
			foreach (GraffitiSpot grafSpot in _worldHandler.SceneObjectsRegister.grafSpots)
			{
				if (Compression.HashString(((AProgressable)grafSpot).Uid) == hash)
				{
					return grafSpot;
				}
			}
			return null;
		}

		private void OnReceive_GraffitiStart(ClientGraffitiRaceStart packet)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			Vector3 position = packet.SpawnPosition.ToUnityVector3();
			Quaternion rotation = packet.SpawnRotation.ToUnityQuaternion();
			if (Settings.SettingByID[SettingSpawnModeID].Value == 2)
			{
				position = ((Component)currentPlayer).transform.position;
				rotation = ((Component)currentPlayer).transform.rotation;
			}
			MPUtility.PlaceCurrentPlayer(position, rotation);
			MPUtility.MakePlayerDance(currentPlayer);
			SetSpawnLocation();
		}

		private void OnReceive_TeamGraffitiRaceScore(ServerTeamGraffRaceScore packet)
		{
			GraffitiSpot graffitiSpotByHash = GetGraffitiSpotByHash(packet.TagHash);
			MarkGraffitiSpotDone(graffitiSpotByHash);
			Player player = ClientController.Players[packet.PlayerId].Player;
			GraffitiArt randomGraffitiArt = TagUtils.GetRandomGraffitiArt(graffitiSpotByHash, player);
			graffitiSpotByHash.Paint((Crew)1, randomGraffitiArt, (Player)null);
		}

		private void OnReceive_GraffitiRaceData(ClientGraffitiRaceGSpots packet)
		{
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			if (_fetchingState != FetchingStates.Started)
			{
				_otherSpots.Clear();
				_originalProgress.Clear();
				foreach (GraffitiSpot grafSpot in _worldHandler.SceneObjectsRegister.grafSpots)
				{
					((Component)grafSpot).gameObject.SetActive(false);
					_otherSpots.Add(grafSpot);
				}
			}
			_fetchingState = FetchingStates.Started;
			if (packet.FinalPacket)
			{
				_fetchingState = FetchingStates.Finished;
			}
			Mapcontroller instance = Mapcontroller.Instance;
			foreach (GraffitiSpot grafSpot2 in _worldHandler.SceneObjectsRegister.grafSpots)
			{
				if (packet.GraffitiSpots.Contains(Compression.HashString(((AProgressable)grafSpot2).Uid)))
				{
					((Component)grafSpot2).gameObject.SetActive(true);
					_otherSpots.Remove(grafSpot2);
				}
			}
			foreach (int graffitiSpot in packet.GraffitiSpots)
			{
				GraffitiSpot graffitiSpotByHash = GetGraffitiSpotByHash(graffitiSpot);
				if ((Object)(object)graffitiSpotByHash == (Object)null)
				{
					ClientLobbyManager.LeaveLobby();
					ChatUI.Instance.AddMessage("Kicked from lobby because your map doesn't match with the lobby host's.");
					break;
				}
				_originalProgress[graffitiSpotByHash] = (GraffitiSpotProgress)((AProgressable)graffitiSpotByHash).progressableData;
				graffitiSpotByHash.ClearPaint();
				graffitiSpotByHash.bottomCrew = (Crew)1;
				_indicators.AddIndicator(((Component)graffitiSpotByHash).transform);
				MapPin val = instance.CreatePin((PinType)2);
				val.AssignGameplayEvent(((Component)graffitiSpotByHash).gameObject);
				val.InitMapPin((PinType)2);
				val.OnPinEnable();
				_mapPins[graffitiSpotByHash] = val;
			}
		}

		private List<GraffitiSpot> GetValidSpots()
		{
			return _worldHandler.SceneObjectsRegister.grafSpots.Where((GraffitiSpot x) => !x.deactivateDuringEncounters && !(x is GraffitiSpotFinisher) && (int)x.attachedTo == 0 && (int)x.notAllowedToPaint != 0 && (Object)(object)((Component)x).GetComponentInParent<Rigidbody>(true) == (Object)null && (int)x.beTargetForObjective == -1 && (Object)(object)((Component)x).GetComponentInParent<ActiveOnChapter>(true) == (Object)null && !MapStationSupport.IsMapOptionToggleable(((Component)x).gameObject)).ToList();
		}

		private void OnStart_Host()
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: 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_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Expected O, but got Unknown
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: 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_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)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: 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_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Expected O, but got Unknown
			List<GraffitiSpot> validSpots = GetValidSpots();
			List<GraffitiSpot> list = new List<GraffitiSpot>();
			int num = Settings.SettingByID[SettingGraffitiAmountID].Value;
			SpawnMode value = (SpawnMode)Settings.SettingByID[SettingSpawnModeID].Value;
			bool isOn = (Settings.SettingByID[SettingSingleGraffitiID] as ToggleGamemodeSetting).IsOn;
			if ((Settings.SettingByID[SettingSingleGraffitiID] as ToggleGamemodeSetting).IsOn)
			{
				num = 1;
			}
			if (validSpots.Count <= 0)
			{
				ClientLobbyManager.EndGame();
				return;
			}
			if (validSpots.Count < num)
			{
				num = Mathf.CeilToInt((float)validSpots.Count * 0.5f);
			}
			for (int i = 0; i < num; i++)
			{
				int index = Random.Range(0, validSpots.Count);
				GraffitiSpot item = validSpots[index];
				validSpots.RemoveAt(index);
				list.Add(item);
			}
			GraffitiSpot obj = list[0];
			Vector3 val = -((Component)obj).transform.forward;
			Vector3 vector = ((Component)obj).transform.position - val * 3f;
			val.y = 0f;
			val = ((Vector3)(ref val)).normalized;
			Quaternion quaternion = Quaternion.LookRotation(val, Vector3.up);
			List<GraffitiSpot> list2 = list;
			if (isOn)
			{
				validSpots.Remove(list[0]);
				ListExtensions.Shuffle<GraffitiSpot>((IList<GraffitiSpot>)validSpots);
				list2 = validSpots;
				if (list2.Count <= 0)
				{
					list2 = list;
				}
			}
			if (value == SpawnMode.Automatic)
			{
				TurnOnAllStageChunks();
				RaycastHit val4 = default(RaycastHit);
				foreach (GraffitiSpot item2 in list2)
				{
					Vector3 val2 = -((Component)item2).transform.forward;
					Vector3 val3 = ((Component)item2).transform.position - val2 * 3f;
					if (Physics.Raycast(new Ray(val3, Vector3.down), ref val4, 1000f, int.MaxValue, (QueryTriggerInteraction)2) && Vector3.Angle(((RaycastHit)(ref val4)).normal, Vector3.up) <= 20f && ((Component)((RaycastHit)(ref val4)).collider).gameObject.layer == 0)
					{
						vector = ((RaycastHit)(ref val4)).point;
						val = -((Component)item2).transform.forward;
						val.y = 0f;
						val = ((Vector3)(ref val)).normalized;
						quaternion = Quaternion.LookRotation(val, Vector3.up);
						if (Physics.OverlapSphere(((RaycastHit)(ref val4)).point + Vector3.up * 1f, 1f, 2048, (QueryTriggerInteraction)2).Length == 0)
						{
							break;
						}
					}
				}
				RestoreStageChunks();
			}
			else
			{
				Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
				vector = ((Component)currentPlayer).transform.position;
				val = ((Component)currentPlayer).transform.forward;
				quaternion = ((Component)currentPlayer).transform.rotation;
			}
			ClientGraffitiRaceStart packet = new ClientGraffitiRaceStart(vector.ToSystemVector3(), quaternion.ToSystemQuaternion());
			ClientController.SendPacket((Packet)(object)packet, (SendModes)1, (NetChannels)1);
			List<List<int>> list3 = new List<List<int>>();
			int num2 = 0;
			List<int> list4 = new List<int>();
			foreach (GraffitiSpot item3 in list)
			{
				if (num2 >= 10)
				{
					list3.Add(list4);
					list4 = new List<int>();
					num2 = 0;
				}
				list4.Add(Compression.HashString(((AProgressable)item3).Uid));
				num2++;
			}
			list3.Add(list4);
			for (int j = 0; j < list3.Count; j++)
			{
				List<int> list5 = list3[j];
				bool flag = j >= list3.Count - 1;
				ClientGraffitiRaceGSpots packet2 = new ClientGraffitiRaceGSpots(list5, flag);
				ClientController.SendPacket((Packet)(object)packet2, (SendModes)1, (NetChannels)1);
			}
		}

		public override GamemodeSettings GetDefaultSettings()
		{
			GamemodeSettings defaultSettings = base.GetDefaultSettings();
			defaultSettings.SettingByID[SettingMoveStyleID] = new GamemodeSetting("Spawn MoveStyle", MoveStyleMode.Force_On_Foot);
			defaultSettings.SettingByID[SettingSpawnModeID] = new GamemodeSetting("Spawn Mode", SpawnMode.Automatic);
			defaultSettings.SettingByID[SettingQuickGraffitiID] = new ToggleGamemodeSetting("Quick Graffiti", on: true);
			defaultSettings.SettingByID[SettingAutoGraffitiID] = new ToggleGamemodeSetting("Auto Graffiti", on: false);
			GamemodeSetting gamemodeSetting = defaultSettings.SettingByID[SettingAutoGraffitiID];
			gamemodeSetting.OnCheckVisibility = (Func<Dictionary<int, GamemodeSetting>, bool>)Delegate.Combine(gamemodeSetting.OnCheckVisibility, (Func<Dictionary<int, GamemodeSetting>, bool>)((Dictionary<int, GamemodeSetting> settingById) => (settingById[SettingQuickGraffitiID] as ToggleGamemodeSetting).IsOn));
			int count = GetValidSpots().Count;
			int min = 5;
			if (count < 5)
			{
				min = 0;
			}
			defaultSettings.SettingByID[SettingGraffitiAmountID] = new GamemodeSetting("Graffiti Amount", 10, min, count, 5);
			GamemodeSetting gamemodeSetting2 = defaultSettings.SettingByID[SettingGraffitiAmountID];
			gamemodeSetting2.OnCheckVisibility = (Func<Dictionary<int, GamemodeSetting>, bool>)Delegate.Combine(gamemodeSetting2.OnCheckVisibility, (Func<Dictionary<int, GamemodeSetting>, bool>)((Dictionary<int, GamemodeSetting> settingById) => !(settingById[SettingSingleGraffitiID] as ToggleGamemodeSetting).IsOn));
			defaultSettings.SettingByID[SettingSingleGraffitiID] = new ToggleGamemodeSetting("Single Graffiti", on: false);
			return defaultSettings;
		}
	}
	public class PropDisguiseController : MonoBehaviour
	{
		public Dictionary<int, GameObject> PropByIndex = new Dictionary<int, GameObject>();

		public Dictionary<GameObject, int> IndexByProp = new Dictionary<GameObject, int>();

		public Dictionary<int, float> SizeByIndex = new Dictionary<int, float>();

		public bool FrozenProps;

		public bool InPropHunt;

		public bool InSetupPhase;

		public PropHuntTeams LocalPropHuntTeam = PropHuntTeams.None;

		private GameObject _currentlyOutlinedGameObject;

		private GameObject _outlineGameObject;

		public float PropVerticalSpeed;

		public float PropHorizontalSpeed;

		public int PropDamage;

		public float PropMinimumSize;

		public float HunterReticleSize;

		public int HunterPelletAmount;

		private string _hSpeedTag = "ph_hspeed=";

		private string _vSpeedTag = "ph_vspeed=";

		private string _damageTag = "ph_damage=";

		private string _sizeTag = "ph_size=";

		private string _reticleTag = "ph_reticle=";

		private string _pelletTag = "ph_pellet=";

		private string _versionIdentifier = "VERSION2";

		private float _oldLodBias;

		public static PropDisguiseController Instance { get; private set; }

		public int StageHash { get; private set; }

		public void LoadTestSettings()
		{
			PropVerticalSpeed = 15f;
			PropHorizontalSpeed = 15f;
			PropDamage = 2;
			PropMinimumSize = 0.1f;
			HunterReticleSize = 1f;
			HunterPelletAmount = 8;
			foreach (string tag in ClientController.Instance.ServerState.Tags)
			{
				if (tag.StartsWith(_hSpeedTag))
				{
					PropHorizontalSpeed = float.Parse(tag.Substring(_hSpeedTag.Length));
				}
				if (tag.StartsWith(_vSpeedTag))
				{
					PropVerticalSpeed = float.Parse(tag.Substring(_vSpeedTag.Length));
				}
				if (tag.StartsWith(_damageTag))
				{
					PropDamage = int.Parse(tag.Substring(_damageTag.Length));
				}
				if (tag.StartsWith(_sizeTag))
				{
					PropMinimumSize = float.Parse(tag.Substring(_sizeTag.Length));
				}
				if (tag.StartsWith(_reticleTag))
				{
					HunterReticleSize = float.Parse(tag.Substring(_reticleTag.Length));
				}
				if (tag.StartsWith(_pelletTag))
				{
					HunterPelletAmount = int.Parse(tag.Substring(_pelletTag.Length));
				}
			}
		}

		public void OutlineGameObject(GameObject obj)
		{
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)obj == (Object)(object)_currentlyOutlinedGameObject)
			{
				return;
			}
			if ((Object)(object)_outlineGameObject != (Object)null)
			{
				Object.Destroy((Object)(object)_outlineGameObject);
				_outlineGameObject = null;
			}
			_currentlyOutlinedGameObject = obj;
			if (!((Object)(object)obj == (Object)null))
			{
				_outlineGameObject = Object.Instantiate<GameObject>(obj);
				Collider[] componentsInChildren = _outlineGameObject.GetComponentsInChildren<Collider>();
				Rigidbody[] componentsInChildren2 = _outlineGameObject.GetComponentsInChildren<Rigidbody>();
				Renderer[] componentsInChildren3 = _outlineGameObject.GetComponentsInChildren<Renderer>();
				_outlineGameObject.GetComponentsInChildren<MeshFilter>();
				StreetLife componentInChildren = _outlineGameObject.GetComponentInChildren<StreetLife>();
				Animator componentInChildren2 = _outlineGameObject.GetComponentInChildren<Animator>();
				if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren2 != (Object)null)
				{
					componentInChildren2.Play(Animator.StringToHash(((object)(IdleAnimation)(ref componentInChildren.idleAnimation)).ToString()), 0);
				}
				if ((Object)(object)componentInChildren2 != (Object)null)
				{
					Object.Destroy((Object)(object)componentInChildren2);
				}
				Collider[] array = componentsInChildren;
				for (int i = 0; i < array.Length; i++)
				{
					Object.Destroy((Object)(object)array[i]);
				}
				Rigidbody[] array2 = componentsInChildren2;
				for (int i = 0; i < array2.Length; i++)
				{
					Object.Destroy((Object)(object)array2[i]);
				}
				Renderer[] array3 = componentsInChildren3;
				for (int i = 0; i < array3.Length; i++)
				{
					array3[i].sharedMaterial = MPAssets.Instance.AimOutlineMaterial;
				}
				_outlineGameObject.transform.position = obj.transform.position;
				_outlineGameObject.transform.rotation = obj.transform.rotation;
				_outlineGameObject.transform.localScale = obj.transform.localScale;
			}
		}

		public static void Create()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new GameObject("Prop Disguise Controller").AddComponent<PropDisguiseController>();
		}

		public void FreezeProps()
		{
			if (!FrozenProps)
			{
				FrozenProps = true;
				MPUtility.ResetProps();
				_oldLodBias = QualitySettings.lodBias;
				QualitySettings.lodBias *= 3f;
			}
		}

		public void UnfreezeProps()
		{
			if (FrozenProps)
			{
				FrozenProps = false;
				QualitySettings.lodBias *= _oldLodBias;
			}
		}

		private void Awake()
		{
			Instance = this;
			CacheProps();
		}

		private void CacheProps()
		{
			//IL_00ac: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: 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_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			Junk[] array = Object.FindObjectsOfType<Junk>();
			StreetLife[] array2 = Object.FindObjectsOfType<StreetLife>();
			Junk[] array3 = array;
			Bounds bounds;
			foreach (Junk val in array3)
			{
				StageChunk componentInParent = ((Component)val).GetComponentInParent<StageChunk>();
				JunkStageHandler componentInParent2 = ((Component)val).GetComponentInParent<JunkStageHandler>();
				if (!((Object)(object)componentInParent == (Object)null) || !((Object)(object)componentInParent2 == (Object)null))
				{
					int num = MPUtility.GenerateGameObjectID(((Component)val).gameObject);
					PropByIndex[num] = ((Component)val).gameObject;
					IndexByProp[((Component)val).gameObject] = num;
					Renderer componentInChildren = ((Component)val).GetComponentInChildren<Renderer>();
					if ((Object)(object)componentInChildren == (Object)null)
					{
						SizeByIndex[num] = 0f;
						continue;
					}
					Dictionary<int, float> sizeByIndex = SizeByIndex;
					float[] array4 = new float[3];
					bounds = componentInChildren.bounds;
					array4[0] = ((Bounds)(ref bounds)).size.x;
					bounds = componentInChildren.bounds;
					array4[1] = ((Bounds)(ref bounds)).size.y;
					bounds = componentInChildren.bounds;
					array4[2] = ((Bounds)(ref bounds)).size.z;
					sizeByIndex[num] = Mathf.Min(array4);
				}
			}
			StreetLife[] array5 = array2;
			foreach (StreetLife val2 in array5)
			{
				if (!((Object)(object)((Component)val2).GetComponentInParent<StageChunk>() == (Object)null) && !((Object)(object)((Component)val2).GetComponent<MoveAlongPoints>() != (Object)null))
				{
					int num2 = MPUtility.GenerateGameObjectID(((Component)val2).gameObject);
					PropByIndex[num2] = ((Component)val2).gameObject;
					IndexByProp[((Component)val2).gameObject] = num2;
					Renderer componentInChildren2 = ((Component)val2).GetComponentInChildren<Renderer>();
					if ((Object)(object)componentInChildren2 == (Object)null)
					{
						SizeByIndex[num2] = 0f;
						continue;
					}
					Dictionary<int, float> sizeByIndex2 = SizeByIndex;
					float[] array6 = new float[3];
					bounds = componentInChildren2.bounds;
					array6[0] = ((Bounds)(ref bounds)).size.x;
					bounds = componentInChildren2.bounds;
					array6[1] = ((Bounds)(ref bounds)).size.y;
					bounds = componentInChildren2.bounds;
					array6[2] = ((Bounds)(ref bounds)).size.z;
					sizeByIndex2[num2] = Mathf.Min(array6);
				}
			}
			string text = "";
			foreach (int key in PropByIndex.Keys)
			{
				text = text + key + "|";
			}
			text += _versionIdentifier;
			StageHash = Compression.HashString(text);
		}
	}
	public class PropHunt : Gamemode
	{
		public enum States
		{
			Setup,
			Main,
			Finished
		}

		private static int SettingSetupDurationID = Animator.StringToHash("SetupDuration");

		private const int DefaultSetupDuration = 1;

		private const int MinSetupDuration = 1;

		private const int MaxSetupDuration = 10;

		private static int SettingMatchDurationID = Animator.StringToHash("MatchDuration");

		private const int DefaultMatchDuration = 5;

		private const int MinMatchDuration = 1;

		private const int MaxMatchDuration = 20;

		private static int SettingPingIntervalID = Animator.StringToHash("PingInterval");

		private const int DefaultPingInterval = 30;

		private const int MinPingInterval = 10;

		private const int MaxPingInterval = 60;

		private static int SettingBecomeHunterOnKillID = Animator.StringToHash("BecomeHunterOnKill");

		private static int SettingRespawnOnKillID = Animator.StringToHash("RespawnOnKill");

		private States _state;

		private float _stateTimer;

		public int SetupDuration => Settings.SettingByID[SettingSetupDurationID].Value;

		public int MatchDuration => Settings.SettingByID[SettingMatchDurationID].Value;

		public int PingInterval => Settings.SettingByID[SettingPingIntervalID].Value;

		public bool BecomeHunterOnKill => (Settings.SettingByID[SettingBecomeHunterOnKillID] as ToggleGamemodeSetting).IsOn;

		public bool RespawnOnKill => (Settings.SettingByID[SettingRespawnOnKillID] as ToggleGamemodeSetting).IsOn;

		public PropHunt()
		{
			TeamBased = true;
			CanChangeCountdown = false;
			MinimapOverrideMode = MinimapOverrideModes.ForceOn;
		}

		public override void OnStart()
		{
			base.OnStart();
			PropHuntUI.Instance.Activate();
			TimerUI.Instance.Activate();
			PropDisguiseController instance = PropDisguiseController.Instance;
			instance.LoadTestSettings();
			instance.FreezeProps();
			instance.InPropHunt = true;
			instance.InSetupPhase = true;
			instance.LocalPropHuntTeam = (PropHuntTeams)Lobby.LobbyState.Players[ClientController.LocalID].Team;
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			ChatUI instance2 = ChatUI.Instance;
			if (instance.LocalPropHuntTeam == PropHuntTeams.Hunters)
			{
				MPUtility.MakePlayerDance(currentPlayer);
				currentPlayer.userInputEnabled = false;
				instance2.AddMessage("<color=yellow>You're a Hunter! Wait for the Setup phase to end before hunting the Props!\nAim and fire at suspicious props. Be careful; you will lose health if you miss.</color>");
			}
			else
			{
				instance2.AddMessage("<color=yellow>You're a Prop! Use the Setup time to find a good place to hide.\nAim at props and turn into them when they're highlighted.</color>");
			}
			((Component)currentPlayer).gameObject.AddComponent<PropHuntPlayer>();
			XHairUI.Create();
			if (ClientController.LocalID == Lobby.LobbyState.HostId)
			{
				OnStart_Host();
			}
			else
			{
				OnStart_Client();
			}
		}

		private void OnStart_Client()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			ClientPropHuntStageHash packet = new ClientPropHuntStageHash(PropDisguiseController.Instance.StageHash);
			ClientController.SendPacket((Packet)(object)packet, (SendModes)1, (NetChannels)1);
		}

		private void OnStart_Host()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			ClientPropHuntSettings packet = new ClientPropHuntSettings((float)SetupDuration * 60f, (float)MatchDuration * 60f, (float)PingInterval, PropDisguiseController.Instance.StageHash, BecomeHunterOnKill, RespawnOnKill, 5f);
			ClientController.SendPacket((Packet)(object)packet, (SendModes)1, (NetChannels)1);
		}

		public override void OnPacketReceived_InGame(Packets packetId, Packet packet)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected I4, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			PropDisguiseController instance = PropDisguiseController.Instance;
			switch (packetId - 55)
			{
			case 0:
				SetState(States.Main);
				break;
			case 2:
			{
				ServerPropHuntSpawn val = (ServerPropHuntSpawn)(object)((packet is ServerPropHuntSpawn) ? packet : null);
				MPUtility.PlaceCurrentPlayer(val.Position.ToUnityVector3(), val.Rotation.ToUnityQuaternion());
				SetSpawnLocation();
				break;
			}
			case 3:
				PingProps();
				break;
			case 5:
				if (!instance.InSetupPhase && instance.InPropHunt && instance.LocalPropHuntTeam == PropHuntTeams.Props)
				{
					Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
					currentPlayer.ChangeHP(instance.PropDamage);
					PropHuntPlayer component = ((Component)currentPlayer).GetComponent<PropHuntPlayer>();
					if ((Object)(object)component != (Object)null)
					{
						component.HitLock();
					}
				}
				break;
			case 6:
				Respawn();
				break;
			case 1:
			case 4:
				break;
			}
		}

		public void OnDie()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			ClientPropHuntDeath packet = new ClientPropHuntDeath();
			ClientController.SendPacket((Packet)(object)packet, (SendModes)1, (NetChannels)1);
			SpectatorController.StartSpectating(forced: true);
			PlayerComponent.GetLocal().LocalIgnore = true;
		}

		private void Respawn()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			SpectatorController instance = SpectatorController.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.EndSpectating();
			}
			WorldHandler.instance.GetCurrentPlayer().ResetHP();
			MPUtility.PlaceCurrentPlayer(SpawnPos, SpawnRot);
			PlayerComponent.GetLocal().LocalIgnore = false;
		}

		private void PingProps()
		{
			foreach (KeyValuePair<ushort, LobbyPlayer> player in Lobby.LobbyState.Players)
			{
				if (player.Value.Team != 1)
				{
					continue;
				}
				GameObject gameObject = ((Component)WorldHandler.instance.GetCurrentPlayer()).gameObject;
				if (player.Key != ClientController.LocalID)
				{
					MPPlayer mPPlayer = ClientController.Players[player.Key];
					if ((mPPlayer.ClientVisualState != null && mPPlayer.ClientVisualState.Ignore) || (Object)(object)mPPlayer.Player == (Object)null)
					{
						continue;
					}
					gameObject = ((Component)mPPlayer.Player).gameObject;
				}
				MPUtility.PingInMap(gameObject, 3f);
			}
		}

		private void SetState(States newState)
		{
			if (newState != _state)
			{
				if (newState != 0)
				{
					PropDisguiseController.Instance.InSetupPhase = false;
					WorldHandler.instance.GetCurrentPlayer().userInputEnabled = true;
				}
				_state = newState;
				_stateTimer = 0f;
			}
		}

		public override void OnUpdate_InGame()
		{
			PropDisguiseController.Instance.LocalPropHuntTeam = (PropHuntTeams)Lobby.LobbyState.Players[ClientController.LocalID].Team;
			TimerUI instance = TimerUI.Instance;
			switch (_state)
			{
			case States.Setup:
			{
				float num2 = (float)SetupDuration * 60f - _stateTimer;
				if (num2 <= 0f)
				{
					num2 = 0f;
				}
				instance.SetText("Setup: " + TimerUI.GetTimeString(num2));
				break;
			}
			case States.Main:
			{
				float num = (float)MatchDuration * 60f - _stateTimer;
				if (num <= 0f)
				{
					num = 0f;
				}
				instance.SetTime(num);
				break;
			}
			}
			_stateTimer += Time.deltaTime;
		}

		public override void OnEnd(bool cancelled)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			PropHuntUI.Instance.Deactivate();
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			currentPlayer.ResetHP();
			MPUtility.PlaceCurrentPlayer(((Component)currentPlayer).transform.position, ((Component)currentPlayer).transform.rotation);
			base.OnEnd(cancelled);
			if (_state == States.Setup)
			{
				currentPlayer.userInputEnabled = true;
			}
			PropDisguiseController instance = PropDisguiseController.Instance;
			instance.UnfreezeProps();
			instance.InPropHunt = false;
			instance.InSetupPhase = false;
			instance.LocalPropHuntTeam = PropHuntTeams.None;
			PlayerComponent local = PlayerComponent.GetLocal();
			local.LocalIgnore = false;
			local.RemovePropDisguise();
			PropHuntPlayer local2 = PropHuntPlayer.GetLocal();
			if ((Object)(object)local2 != (Object)null)
			{
				Object.Destroy((Object)(object)local2);
			}
			if ((Object)(object)XHairUI.Instance != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)XHairUI.Instance).gameObject);
			}
			TimerUI instance2 = TimerUI.Instance;
			if ((Object)(object)instance2 != (Object)null)
			{
				instance2.DeactivateDelayed();
			}
			if (!cancelled)
			{
				MPSaveData.Instance.PropHuntPlaytester = true;
				Core.Instance.SaveManager.SaveCurrentSaveSlot();
			}
		}

		public override GamemodeSettings GetDefaultSettings()
		{
			GamemodeSettings defaultSettings = base.GetDefaultSettings();
			defaultSettings.SettingByID[SettingSetupDurationID] = new GamemodeSetting("Setup Duration (Minutes)", 1, 1, 10);
			defaultSettings.SettingByID[SettingMatchDurationID] = new GamemodeSetting("Match Duration (Minutes)", 5, 1, 20);
			defaultSettings.SettingByID[SettingPingIntervalID] = new GamemodeSetting("Ping Interval (Seconds)", 30, 10, 60, 10);
			defaultSettings.SettingByID[SettingBecomeHunterOnKillID] = new ToggleGamemodeSetting("Props Become Hunters on Death", on: true);
			defaultSettings.SettingByID[SettingRespawnOnKillID] = new ToggleGamemodeSetting("Hunters Respawn on Death", on: true);
			return defaultSettings;
		}
	}
	public enum PropHuntTeams
	{
		Hunters,
		Props,
		None
	}
	public class ProSkaterScoreBattle : ScoreBattle
	{
		private static int SettingRewardTiltingID = Animator.StringToHash("RewardTilting");

		public bool RewardTilting => (Settings.SettingByID[SettingRewardTiltingID] as ToggleGamemodeSetting).IsOn;

		public ProSkaterScoreBattle()
		{
			ComboBased = true;
		}

		public override void OnStart()
		{
			base.OnStart();
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			currentPlayer.CompletelyStop();
			ProSkaterPlayer.Set(currentPlayer, set: true);
		}

		public override void OnEnd(bool cancelled)
		{
			base.OnEnd(cancelled);
			if ((Object)(object)WorldHandler.instance != (Object)null)
			{
				Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
				if ((Object)(object)currentPlayer != (Object)null)
				{
					currentPlayer.CompletelyStop();
					ProSkaterPlayer.Set(currentPlayer, set: false);
				}
			}
		}

		public override GamemodeSettings GetDefaultSettings()
		{
			GamemodeSettings defaultSettings = base.GetDefaultSettings();
			defaultSettings.SettingByID[SettingRewardTiltingID] = new ToggleGamemodeSetting("Reward Grind Corners", on: true);
			return defaultSettings;
		}
	}
	public class SavedGamemodeSettings
	{
		public Dictionary<int, int> ValueByID = new Dictionary<int, int>();

		private const byte Version = 0;

		public void Read(BinaryReader reader)
		{
			reader.ReadByte();
			int num = reader.ReadInt32();
			for (int i = 0; i < num; i++)
			{
				int key = reader.ReadInt32();
				int value = reader.ReadInt32();
				ValueByID[key] = value;
			}
		}

		public void Write(BinaryWriter writer)
		{
			writer.Write((byte)0);
			writer.Write(ValueByID.Count);
			foreach (KeyValuePair<int, int> item in ValueByID)
			{
				writer.Write(item.Key);
				writer.Write(item.Value);
			}
		}
	}
	public class ScoreBattle : Gamemode
	{
		public enum SpawnMode
		{
			Current_Positions,
			At_Host
		}

		public enum States
		{
			Countdown,
			Main,
			Finished
		}

		[CompilerGenerated]
		private sealed class <Cheer>d__19 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Cheer>d__19(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(Random.Range(0.5f, 1f));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)player != (Object)null && !player.IsDead() && !player.IsBusyWithSequence())
					{
						try
						{
							player.PlayVoice((AudioClipID)498, (VoicePriority)3, true);
						}
						catch (Exception)
						{
						}
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private const float ScoreUpdateRate = 0.2f;

		private static int SettingDurationID = Animator.StringToHash("Duration");

		private const int DefaultDuration = 3;

		private const int MinDuration = 1;

		private const int MaxDuration = 10;

		private static int SettingSpawnModeID = Animator.StringToHash("SpawnMode");

		private float _scoreTimer;

		private States _state;

		private float _stateTimer;

		private DateTime _startTime = DateTime.UtcNow;

		public bool ComboBased;

		private bool _comboOverRegistered;

		public override void OnStart()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			base.OnStart();
			if (Settings.SettingByID[SettingSpawnModeID].Value == 1)
			{
				ClientVisualState clientVisualState = ClientController.Instance.Players[Lobby.LobbyState.HostId].ClientVisualState;
				MPUtility.PlaceCurrentPlayer(clientVisualState.Position.ToUnityVector3(), clientVisualState.Rotation.ToUnityQuaternion());
			}
			if (ClientController.Instance.LocalID == Lobby.LobbyState.HostId)
			{
				ClientController.SendPacket((Packet)new ClientScoreBattleLength((byte)Settings.SettingByID[SettingDurationID].Value), (SendModes)1, (NetChannels)1);
			}
			TimerUI.Instance.Activate();
			SetSpawnLocation();
		}

		public override void OnUpdate_InGame()
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			TimerUI instance = TimerUI.Instance;
			switch (_state)
			{
			case States.Countdown:
			{
				int num3 = Mathf.FloorToInt(_stateTimer);
				instance.SetText(Mathf.Max(1, base.Countdown - num3).ToString());
				currentPlayer.boostCharge = currentPlayer.maxBoostCharge;
				break;
			}
			case States.Main:
			{
				float num = (float)(DateTime.UtcNow - _startTime).TotalSeconds;
				float num2 = (float)Settings.SettingByID[SettingDurationID].Value * 60f - num;
				if (num2 <= 0f)
				{
					num2 = 0f;
					if (ComboBased && !currentPlayer.IsComboing() && !_comboOverRegistered)
					{
						_comboOverRegistered = true;
						ClientController.SendPacket((Packet)new ClientComboOver(currentPlayer.score), (SendModes)2, (NetChannels)1);
					}
				}
				instance.SetTime(num2);
				if (num2 <= 0f && ComboBased)
				{
					if (currentPlayer.IsComboing() && !_comboOverRegistered)
					{
						instance.SetText("Overtime");
					}
					else
					{
						instance.SetText("Waiting for other players...");
					}
				}
				break;
			}
			}
			_stateTimer += Time.deltaTime;
		}

		private void BeginMainEvent()
		{
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			if (currentPlayer.IsComboing())
			{
				currentPlayer.scoreMultiplier = 1f;
			}
			else
			{
				currentPlayer.scoreMultiplier = 0f;
				currentPlayer.tricksInCombo = 1;
			}
			currentPlayer.boostCharge = currentPlayer.maxBoostCharge;
			currentPlayer.lastScore = 0f;
			currentPlayer.lastCornered = 0;
			currentPlayer.ClearMultipliersDone();
			currentPlayer.comboTimeOutTimer = 1f;
			currentPlayer.RefreshAirTricks();
			currentPlayer.RefreshAllDegrade();
			currentPlayer.score = 0f;
			currentPlayer.baseScore = 0f;
			currentPlayer.grindAbility.trickTimer = 0f;
			_state = States.Main;
		}

		public override void OnEnd(bool cancelled)
		{
			base.OnEnd(cancelled);
			if ((Object)(object)TimerUI.Instance != (Object)null)
			{
				if (!cancelled)
				{
					TimerUI.Instance.SetText("Finish!");
				}
				else
				{
					TimerUI.Instance.SetText("Cancelled!");
				}
				TimerUI.Instance.DeactivateDelayed();
			}
			if (!((Object)(object)WorldHandler.instance != (Object)null))
			{
				return;
			}
			Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
			if (!cancelled)
			{
				bool flag = Lobby.LobbyState.Players.Count >= 2;
				if (TeamBased && flag && GetTeamAmount() <= 1)
				{
					flag = false;
				}
				if (flag && GetWinningPlayers().Contains(ClientController.Instance.LocalID) && (Object)(object)currentPlayer != (Object)null)
				{
					((MonoBehaviour)currentPlayer).StartCoroutine(Cheer(currentPlayer));
				}
			}
			if ((Object)(object)currentPlayer != (Object)null)
			{
				currentPlayer.userInputEnabled = true;
			}
		}

		[IteratorStateMachine(typeof(<Cheer>d__19))]
		private IEnumerator Cheer(Player player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Cheer>d__19(0)
			{
				player = player
			};
		}

		public override void OnPacketReceived_InGame(Packets packetId, Packet packet)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((int)packetId == 19)
			{
				ServerGamemodeBegin val = (ServerGamemodeBegin)packet;
				_startTime = val.StartTime;
				BeginMainEvent();
			}
		}

		public override void OnTick_InGame()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			_scoreTimer += ClientController.DeltaTime;
			if (!(_scoreTimer >= 0.2f))
			{
				return;
			}
			if (_state == States.Main)
			{
				Player currentPlayer = WorldHandler.instance.GetCurrentPlayer();
				float num = currentPlayer.score;
				if (currentPlayer.IsComboing() && !ComboBased)
				{
					num += currentPlayer.baseScore * currentPlayer.scoreMultiplier;
				}
				ClientController.SendPacket((Packet)new ClientGamemodeScore(num), (SendModes)1, (NetChannels)1);
			}
			_scoreTimer = 0f;
		}

		public override GamemodeSettings GetDefaultSettings()
		{
			GamemodeSettings defaultSettings = base.GetDefaultSettings();
			defaultSettings.SettingByID[SettingSpawnModeID] = new GamemodeSetting("Spawn Mode", SpawnMode.Current_Positions);
			defaultSettings.SettingByID[SettingDurationID] = new GamemodeSetting("Duration (Minutes)", 3, 1, 10);
			return defaultSettings;
		}
	}
	public class TeamGraffitiRace : GraffitiRace
	{
		public TeamGraffitiRace()
		{
			TeamBased = true;
		}
	}
	public class TeamProSkaterScoreBattle : ProSkaterScoreBattle
	{
		public TeamProSkaterScoreBattle()
		{
			TeamBased = true;
		}
	}
	public class TeamScoreBattle : ScoreBattle
	{
		public TeamScoreBattle()
		{
			TeamBased = true;
		}
	}
	public class ToggleGamemodeSetting : GamemodeSetting
	{
		public enum Toggle
		{
			ON,
			OFF
		}

		public bool IsOn => Value == 0;

		public ToggleGamemodeSetting(string label, bool on)
			: base(label, (!on) ? Toggle.OFF : Toggle.ON)
		{
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}