using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using I2.Loc;
using JetBrains.Annotations;
using MPUIKIT;
using Microsoft.CodeAnalysis;
using MoreMountains.Feedbacks;
using NGS.MeshFusionPro;
using On;
using Pathfinding;
using Pathfinding.RVO;
using Rewired;
using Shapes;
using Steamworks;
using TMPro;
using ThronefallMP.Components;
using ThronefallMP.Network;
using ThronefallMP.Network.Packets;
using ThronefallMP.Network.Packets.Administration;
using ThronefallMP.Network.Packets.Game;
using ThronefallMP.Network.Packets.PlayerCommand;
using ThronefallMP.Network.Packets.Sync;
using ThronefallMP.Network.Sync;
using ThronefallMP.Patches;
using ThronefallMP.UI;
using ThronefallMP.UI.Controls;
using ThronefallMP.UI.Dialogs;
using ThronefallMP.UI.Panels;
using ThronefallMP.Utils;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Experimental.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.TextCore.LowLevel;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyFileVersion("1.2.2.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
internal static class PluginInfo
{
	public const string PLUGIN_GUID = "com.badwolf.thronefall_mp";

	public const string PLUGIN_NAME = "Thronefall Multiplayer";

	public const string PLUGIN_VERSION = "1.2.2";
}
namespace ThronefallMP
{
	public class CheatHandler
	{
		private delegate bool CheatMessageHandler(string user, string[] parts);

		private Dictionary<string, CheatMessageHandler> _handlers = new Dictionary<string, CheatMessageHandler>();

		private static bool CheatsEnabled => !Plugin.Instance.Network.Online || (SteamManager.Initialized && SteamMatchmaking.GetLobbyData(Plugin.Instance.Network.Lobby, "cheats_enabled") == "yes");

		public CheatHandler()
		{
			_handlers.Add("add_coins", AddCoins);
			Plugin.Instance.Network.AddChatMessageHandler(100, OnMessageReceived);
		}

		private bool OnMessageReceived(string user, string message)
		{
			if (!CheatsEnabled || !Plugin.Instance.Network.Server || !message.StartsWith("/"))
			{
				return false;
			}
			message = message.Remove(0, 1);
			Plugin.Log.LogInfo((object)("Parsing cheat '" + message + "'"));
			string[] array = message.Split(' ');
			Plugin.Log.LogInfo((object)("Command '" + array[0] + "'"));
			if (_handlers.TryGetValue(array[0], out var value))
			{
				return value(user, array.Skip(1).ToArray());
			}
			Plugin.Log.LogInfo((object)"Not found");
			return false;
		}

		private bool AddCoins(string user, string[] parts)
		{
			if (parts.Length != 1)
			{
				Plugin.Log.LogInfo((object)"Too many arguments");
				return false;
			}
			if (!int.TryParse(parts[0], out var result))
			{
				Plugin.Log.LogInfo((object)"Failed to parse coins");
				return false;
			}
			GlobalData.Balance += result;
			Plugin.Instance.Network.SendServerMessage($"{user} Cheated in {result} coins.");
			return true;
		}
	}
	public enum Equipment
	{
		Invalid,
		PerkPoint,
		LongBow,
		LightSpear,
		HeavySword,
		LightningWand,
		RoyalMint,
		ArcaneTowers,
		HeavyArmor,
		CastleFortifications,
		RingOfResurrection,
		PumpkinFields,
		ArchitectsCouncil,
		GodsLotion,
		CastleBlueprints,
		GladiatorSchool,
		WarHorse,
		GlassCannon,
		BigHarbours,
		EliteWarriors,
		ArcherySkills,
		FasterResearch,
		TowerSupport,
		FortifiedHouses,
		CommanderMode,
		HealingSpirits,
		IceMagic,
		MeleeResistance,
		PowerTower,
		RangedResistance,
		TreasureHunter,
		IndestructibleMines,
		WarriorMode,
		MeleeDamage,
		FirewingHero,
		AntiAirTelescope,
		RangedDamage,
		StrongerHeroes,
		LizardRiderHero,
		AssassinsTraining,
		MagicArmor,
		GodlyCurse,
		CastleUp,
		MillScarecrow,
		MillWindSpirits,
		TowerHotOil,
		MeleeFlails,
		RangedHunters,
		MeleeBerserkers,
		RangedFireArchers,
		WarGods,
		Turtle,
		Tiger,
		Rat,
		Falcon,
		Destruction,
		Wasp,
		Death,
		Phoenix,
		NoWallsPact,
		NoTowersPact,
		NoUnitsPact,
		BattleAxe,
		BloodWand,
		CursedBlowpipe,
		FalchionAndTrap,
		AgileHorse,
		AncientShrines,
		Cobbler,
		DoubleHealing,
		EliteTowers,
		EmergencyRepairs,
		ExperienceGain,
		ExplosiveRevival,
		ExplosiveWalls,
		HealingGold,
		HealthPotions,
		Interest,
		LastStand,
		LightMaterials,
		Loan,
		Outpost,
		PotionVials,
		PristineArchers,
		PristineWarriors,
		RelentlessResearch,
		ResilientResidences,
		RiskTaker,
		RoyalProtection,
		SpellScroll,
		TimberScaffolding,
		TowerArmor,
		TowerBunker,
		EliteGod,
		GrowthGod,
		RangeGod,
		ChaosGod,
		AfterlifeGod,
		ChoiceGod,
		PacifistPact
	}
	public static class Equip
	{
		public static readonly HashSet<Equipment> Weapons = new HashSet<Equipment>
		{
			Equipment.LongBow,
			Equipment.LightSpear,
			Equipment.HeavySword,
			Equipment.LightningWand,
			Equipment.BattleAxe,
			Equipment.BloodWand,
			Equipment.CursedBlowpipe,
			Equipment.FalchionAndTrap
		};

		private static readonly Dictionary<string, Equipment> NameToEquip = new Dictionary<string, Equipment>
		{
			{
				"",
				Equipment.Invalid
			},
			{
				"Perk Point",
				Equipment.PerkPoint
			},
			{
				"Long Bow",
				Equipment.LongBow
			},
			{
				"Light Spear",
				Equipment.LightSpear
			},
			{
				"Heavy Sword",
				Equipment.HeavySword
			},
			{
				"Lightning Wand",
				Equipment.LightningWand
			},
			{
				"Universal Income",
				Equipment.RoyalMint
			},
			{
				"Arcane Towers",
				Equipment.ArcaneTowers
			},
			{
				"Heavy Armor",
				Equipment.HeavyArmor
			},
			{
				"Castle Fortifications",
				Equipment.CastleFortifications
			},
			{
				"Ring of Resurection",
				Equipment.RingOfResurrection
			},
			{
				"Pumpkin Fields",
				Equipment.PumpkinFields
			},
			{
				"Architect's Council",
				Equipment.ArchitectsCouncil
			},
			{
				"Gods Lotion",
				Equipment.GodsLotion
			},
			{
				"Castle Blueprints",
				Equipment.CastleBlueprints
			},
			{
				"Gladiator School",
				Equipment.GladiatorSchool
			},
			{
				"War Horse",
				Equipment.WarHorse
			},
			{
				"Glass Canon",
				Equipment.GlassCannon
			},
			{
				"Big Harbours",
				Equipment.BigHarbours
			},
			{
				"Ellite Warriors",
				Equipment.EliteWarriors
			},
			{
				"Archery Skills",
				Equipment.ArcherySkills
			},
			{
				"Faster Research",
				Equipment.FasterResearch
			},
			{
				"TowerSupport",
				Equipment.TowerSupport
			},
			{
				"Fortified Houses",
				Equipment.FortifiedHouses
			},
			{
				"Commander Mode",
				Equipment.CommanderMode
			},
			{
				"Healing Spirits",
				Equipment.HealingSpirits
			},
			{
				"Ice Magic",
				Equipment.IceMagic
			},
			{
				"Melee Resistence",
				Equipment.MeleeResistance
			},
			{
				"Power Tower",
				Equipment.PowerTower
			},
			{
				"Ranged Resistence",
				Equipment.RangedResistance
			},
			{
				"Treasure Hunter",
				Equipment.TreasureHunter
			},
			{
				"Indestructible Mines",
				Equipment.IndestructibleMines
			},
			{
				"Warrior Mode",
				Equipment.WarriorMode
			},
			{
				"Melee Damage",
				Equipment.MeleeDamage
			},
			{
				"Firewing Hero",
				Equipment.FirewingHero
			},
			{
				"Anti Air Telescope",
				Equipment.AntiAirTelescope
			},
			{
				"Ranged Damage",
				Equipment.RangedDamage
			},
			{
				"Stronger Heros",
				Equipment.StrongerHeroes
			},
			{
				"LizzardRider Hero",
				Equipment.LizardRiderHero
			},
			{
				"CCAssassinsTraining",
				Equipment.AssassinsTraining
			},
			{
				"CCMagicArmor",
				Equipment.MagicArmor
			},
			{
				"CCGodlyCurse",
				Equipment.GodlyCurse
			},
			{
				"CCCastleUp",
				Equipment.CastleUp
			},
			{
				"MillScarecrow",
				Equipment.MillScarecrow
			},
			{
				"MillWindSpirits",
				Equipment.MillWindSpirits
			},
			{
				"TowerHotOil",
				Equipment.TowerHotOil
			},
			{
				"MeleeFlails",
				Equipment.MeleeFlails
			},
			{
				"RangedHunters",
				Equipment.RangedHunters
			},
			{
				"MeleeBerserks",
				Equipment.MeleeBerserkers
			},
			{
				"RangedFireArchers",
				Equipment.RangedFireArchers
			},
			{
				"Pray to The God of Strength",
				Equipment.WarGods
			},
			{
				"Taunt The Turtle God",
				Equipment.Turtle
			},
			{
				"Taunt The Tiger God",
				Equipment.Tiger
			},
			{
				"Taunt The Rat God",
				Equipment.Rat
			},
			{
				"Taunt The Falcon God",
				Equipment.Falcon
			},
			{
				"Taunt God of Destruction",
				Equipment.Destruction
			},
			{
				"Taunt The Cheese God",
				Equipment.Wasp
			},
			{
				"Taunt The Disease God",
				Equipment.Death
			},
			{
				"Taunt the Phoenix God",
				Equipment.Phoenix
			},
			{
				"No Walls Pact",
				Equipment.NoWallsPact
			},
			{
				"No Towers Pact",
				Equipment.NoTowersPact
			},
			{
				"No Units Pact",
				Equipment.NoUnitsPact
			},
			{
				"Battle Axe",
				Equipment.BattleAxe
			},
			{
				"Blood Wand",
				Equipment.BloodWand
			},
			{
				"Cursed Blowpipe",
				Equipment.CursedBlowpipe
			},
			{
				"Falchion and Trap",
				Equipment.FalchionAndTrap
			},
			{
				"Agile Horse",
				Equipment.AgileHorse
			},
			{
				"Ancient Shrines",
				Equipment.AncientShrines
			},
			{
				"Cobbler",
				Equipment.Cobbler
			},
			{
				"Double Healing",
				Equipment.DoubleHealing
			},
			{
				"Elite Towers",
				Equipment.EliteTowers
			},
			{
				"Emergency Repairs",
				Equipment.EmergencyRepairs
			},
			{
				"Experience Gain",
				Equipment.ExperienceGain
			},
			{
				"Explosive Revival",
				Equipment.ExplosiveRevival
			},
			{
				"Explosive Walls",
				Equipment.ExplosiveWalls
			},
			{
				"Healing Gold",
				Equipment.HealingGold
			},
			{
				"Health Potions",
				Equipment.HealthPotions
			},
			{
				"Interest",
				Equipment.Interest
			},
			{
				"Last Stand",
				Equipment.LastStand
			},
			{
				"Light Materials",
				Equipment.LightMaterials
			},
			{
				"Loan",
				Equipment.Loan
			},
			{
				"Outpost",
				Equipment.Outpost
			},
			{
				"Potion Vials",
				Equipment.PotionVials
			},
			{
				"Pristine Archers",
				Equipment.PristineArchers
			},
			{
				"Pristine Warriors",
				Equipment.PristineWarriors
			},
			{
				"Relentless Research",
				Equipment.RelentlessResearch
			},
			{
				"Resilient Residences",
				Equipment.ResilientResidences
			},
			{
				"Risk Taker",
				Equipment.RiskTaker
			},
			{
				"Royal Protection",
				Equipment.RoyalProtection
			},
			{
				"Spell Scroll",
				Equipment.SpellScroll
			},
			{
				"Timber Scaffolding",
				Equipment.TimberScaffolding
			},
			{
				"TowerArmor",
				Equipment.TowerArmor
			},
			{
				"TowerBunker",
				Equipment.TowerBunker
			},
			{
				"Challenge the Elite God",
				Equipment.EliteGod
			},
			{
				"Challenge the Growth God",
				Equipment.GrowthGod
			},
			{
				"Challenge the Range God",
				Equipment.RangeGod
			},
			{
				"Challenge the God of Chaos",
				Equipment.ChaosGod
			},
			{
				"Challenge the God of Afterlife",
				Equipment.AfterlifeGod
			},
			{
				"Challenge the God of Choice",
				Equipment.ChoiceGod
			},
			{
				"Pacifist Pact",
				Equipment.PacifistPact
			}
		};

		private static readonly Dictionary<Equipment, Equippable> EquipmentToEquippable = new Dictionary<Equipment, Equippable>();

		private static readonly Dictionary<Equippable, Equipment> EquippableToEquipment = new Dictionary<Equippable, Equipment>();

		private static bool _initialized;

		private static void InitializeDictionaries()
		{
			_initialized = true;
			Traverse<List<MetaLevel>> val = Traverse.Create((object)PerkManager.instance).Field<List<MetaLevel>>("metaLevels");
			Plugin.Log.LogInfoFiltered("Equipment", "Initializing converter dictionary");
			Plugin.Log.LogInfoFiltered("Equipment", "Meta levels");
			foreach (MetaLevel item in val.Value)
			{
				Equipment equipment = Convert(((Object)item.reward).name);
				Plugin.Log.LogInfoFiltered("Equipment", $"- {equipment} = {((Object)item.reward).name}");
				if (equipment == Equipment.Invalid)
				{
					Plugin.Log.LogWarning((object)("Equippable '" + ((Object)item.reward).name + "' is not in the equipment table"));
					continue;
				}
				EquipmentToEquippable[equipment] = item.reward;
				EquippableToEquipment[item.reward] = equipment;
			}
			Plugin.Log.LogInfoFiltered("Equipment", "Currently Unlocked");
			foreach (Equippable allEquippable in PerkManager.instance.allEquippables)
			{
				Equipment equipment2 = Convert(((Object)allEquippable).name);
				Plugin.Log.LogInfoFiltered("Equipment", $"- {equipment2} = {((Object)allEquippable).name}");
				if (equipment2 == Equipment.Invalid)
				{
					Plugin.Log.LogWarning((object)("Equippable '" + ((Object)allEquippable).name + "' is not in the equipment table"));
					continue;
				}
				EquipmentToEquippable[equipment2] = allEquippable;
				EquippableToEquipment[allEquippable] = equipment2;
			}
		}

		public static void ClearEquipments()
		{
			Plugin.Log.LogInfoFiltered("Equipment", "Clearing equipment");
			PerkManager.instance.CurrentlyEquipped.Clear();
		}

		public static void EquipEquipment(Equipment equipment)
		{
			if (!_initialized)
			{
				InitializeDictionaries();
			}
			if (!EquipmentToEquippable.TryGetValue(equipment, out var value))
			{
				Plugin.Log.LogWarning((object)$"Cannot equip unknown equipment '{equipment}', skipping");
				return;
			}
			Plugin.Log.LogInfoFiltered("Equipment", $"Equipping {equipment} -> {((Object)value).name} (\"{value.displayName}\")");
			PerkManager.instance.CurrentlyEquipped.Add(value);
		}

		public static Equipment Convert(Equippable equip)
		{
			if (!_initialized)
			{
				InitializeDictionaries();
			}
			return GeneralExtensions.GetValueSafe<Equippable, Equipment>(EquippableToEquipment, equip);
		}

		public static Equippable Convert(Equipment equip)
		{
			if (!_initialized)
			{
				InitializeDictionaries();
			}
			return GeneralExtensions.GetValueSafe<Equipment, Equippable>(EquipmentToEquippable, equip);
		}

		public static Equipment Convert(string name)
		{
			return GeneralExtensions.GetValueSafe<string, Equipment>(NameToEquip, name);
		}
	}
	public struct InternalGlobalData
	{
		public int Balance;

		public int NetWorth;
	}
	public static class GlobalData
	{
		public static InternalGlobalData Internal;

		public static int LocalBalanceDelta;

		public static int Balance
		{
			get
			{
				return Plugin.Instance.Network.Server ? Internal.Balance : (Internal.Balance + LocalBalanceDelta);
			}
			set
			{
				if (Plugin.Instance.Network.Server)
				{
					Internal.Balance = value;
				}
				else
				{
					LocalBalanceDelta = value - Internal.Balance;
				}
			}
		}

		public static int NetWorth => Internal.NetWorth;
	}
	[BepInPlugin("com.badwolf.thronefall_mp", "Thronefall Multiplayer", "1.2.2")]
	[BepInProcess("Thronefall.exe")]
	public class Plugin : BaseUnityPlugin
	{
		public delegate void LoadCallback();

		public const string VersionString = "thronefall_mp_1.2.2";

		public static readonly Random Random = new Random();

		[UsedImplicitly]
		public PingPongSync PingPongSync = new PingPongSync();

		[UsedImplicitly]
		public LevelDataSync LevelDataSync = new LevelDataSync();

		[UsedImplicitly]
		public ResourceSync ResourceSync = new ResourceSync();

		[UsedImplicitly]
		public InputSync InputSync = new InputSync();

		[UsedImplicitly]
		public PositionSync PositionSync = new PositionSync();

		[UsedImplicitly]
		public HpSync HpSync = new HpSync();

		[UsedImplicitly]
		public AllyPathfinderSync AllyPathfinderSync = new AllyPathfinderSync();

		[UsedImplicitly]
		public EnemyPathfinderSync EnemyPathfinderSync = new EnemyPathfinderSync();

		private static Dictionary<string, List<(bool waitForTransition, LoadCallback callback)>> _loadCallbacks = new Dictionary<string, List<(bool, LoadCallback)>>();

		public static Plugin Instance { get; private set; }

		public static ManualLogSource Log { get; private set; }

		public ThronefallMP.Network.Network Network { get; private set; }

		public PlayerManager PlayerManager { get; private set; }

		public TextureRepository TextureRepository { get; private set; }

		[UsedImplicitly]
		public CheatHandler CheatHandler { get; private set; }

		private void Awake()
		{
			ConfigEntry<bool> val = ((BaseUnityPlugin)this).Config.Bind<bool>("Network", "EnableSimulation", false, "Enable simulation of a bad network for debugging");
			Instance = this;
			TextureRepository = new TextureRepository();
			Network = ((Component)Instance).gameObject.AddComponent<ThronefallMP.Network.Network>();
			((Component)this).gameObject.AddComponent<LoadoutWatcher>();
			PlayerManager = new PlayerManager();
			CheatHandler = new CheatHandler();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin com.badwolf.thronefall_mp is loaded!");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"===== Thronefall Multiplayer v1.2.2 =====");
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)$"Little Endian: {BitConverter.IsLittleEndian}");
			if (SteamManager.Initialized)
			{
				SetSteamNetworkConfigValues();
				if (val.Value)
				{
					SetSteamNetworkSimulationValues();
				}
			}
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), (string)null);
			BuildingInteractorPatch.Apply();
			BuildSlotPatch.Apply();
			CameraRigPatch.Apply();
			CommandUnitsPatch.Apply();
			CostDisplayPatch.Apply();
			DayNightCyclePatch.Apply();
			EnemySpawnerPatch.Apply();
			GateOpenerPatch.Apply();
			HpPatch.Apply();
			InGameResignUIHelperPatch.Apply();
			LevelBorderPatch.Apply();
			LevelSelectManagerPatch.Apply();
			NightCallPatch.Apply();
			PathFinderMovementEnemyPatch.Apply();
			PathfindMovementPlayerunitPatch.Apply();
			PerkHpModifyerPatch.Apply();
			PerkWeaponModifyerPatch.Apply();
			PlayerAttackPatch.Apply();
			PlayerInteractionPatch.Apply();
			PlayerMovementPatch.Apply();
			PlayerSceptPatch.Apply();
			RevivePanelPatch.Apply();
			SceneTransitionManagerPatch.Apply();
			SteamManagerPatch.Apply();
			TreasuryUIPatch.Apply();
			UIFrameManagerPatch.Apply();
			UIFramePatch.Apply();
			UnitRespawnerForBuildingsPatch.Apply();
			UpgradeAssassinsTrainingPatch.Apply();
			WeaponEquipperPatch.Apply();
			Application.runInBackground = true;
			SceneManager.sceneLoaded += OnSceneChanged;
		}

		private void OnUIInitialized()
		{
			UIManager.Initialize();
			ConfigEntry<bool> val = ((BaseUnityPlugin)this).Config.Bind<bool>("Network", "EnableSimulation", false, "Enable simulation of a bad network for debugging");
			if (val.Value)
			{
				UIManager.CreateMessageDialog("Network Debug Simulation", "Simulation of a bad network is enabled");
			}
		}

		private void OnSceneChanged(Scene scene, LoadSceneMode mode)
		{
			if (((Scene)(ref scene)).name == "_UI")
			{
				OnUIInitialized();
			}
			if (!_loadCallbacks.TryGetValue(((Scene)(ref scene)).name, out List<(bool, LoadCallback)> value))
			{
				return;
			}
			foreach (var item in value)
			{
				if (item.Item1)
				{
					CallbackOnFinishTransition(item.Item2);
				}
				else
				{
					item.Item2();
				}
			}
			value.Clear();
		}

		public static void CallbackOnLoad(string scene, bool waitForTransition, LoadCallback callback)
		{
			if (!_loadCallbacks.TryGetValue(scene, out List<(bool, LoadCallback)> value))
			{
				value = new List<(bool, LoadCallback)>();
				_loadCallbacks[scene] = value;
			}
			value.Add((waitForTransition, callback));
		}

		private static void CallbackOnFinishTransition(LoadCallback callback)
		{
			((MonoBehaviour)Instance).StartCoroutine(WaitForTransition(callback));
		}

		private static IEnumerator WaitForTransition(LoadCallback callback)
		{
			while (SceneTransitionManager.instance.SceneTransitionIsRunning)
			{
				yield return null;
			}
			callback?.Invoke();
		}

		private void SetSteamNetworkConfigValues()
		{
			SetSteamNetworkValue((ESteamNetworkingConfigValue)24, (ESteamNetworkingConfigDataType)1, 1600);
			SetSteamNetworkValue((ESteamNetworkingConfigValue)25, (ESteamNetworkingConfigDataType)1, 3200);
			SetSteamNetworkValue((ESteamNetworkingConfigValue)9, (ESteamNetworkingConfigDataType)1, 4194304);
		}

		private void SetSteamNetworkSimulationValues()
		{
			SetSteamNetworkValue((ESteamNetworkingConfigValue)2, (ESteamNetworkingConfigDataType)3, ((BaseUnityPlugin)this).Config.Bind<float>("Network", "PacketLossSendPercentage", 0.3f, (ConfigDescription)null).Value);
			SetSteamNetworkValue((ESteamNetworkingConfigValue)3, (ESteamNetworkingConfigDataType)3, ((BaseUnityPlugin)this).Config.Bind<float>("Network", "PacketLossReceivePercentage", 0.3f, (ConfigDescription)null).Value);
			SetSteamNetworkValue((ESteamNetworkingConfigValue)4, (ESteamNetworkingConfigDataType)1, ((BaseUnityPlugin)this).Config.Bind<int>("Network", "PacketLagSendMs", 80, (ConfigDescription)null).Value);
			SetSteamNetworkValue((ESteamNetworkingConfigValue)5, (ESteamNetworkingConfigDataType)1, ((BaseUnityPlugin)this).Config.Bind<int>("Network", "PacketLagReceiveMs", 80, (ConfigDescription)null).Value);
			SetSteamNetworkValue((ESteamNetworkingConfigValue)6, (ESteamNetworkingConfigDataType)3, ((BaseUnityPlugin)this).Config.Bind<float>("Network", "PacketReorderPercentageSend", 0.1f, (ConfigDescription)null).Value);
			SetSteamNetworkValue((ESteamNetworkingConfigValue)7, (ESteamNetworkingConfigDataType)3, ((BaseUnityPlugin)this).Config.Bind<float>("Network", "PacketReorderPercentageReceive", 0.1f, (ConfigDescription)null).Value);
			SetSteamNetworkValue((ESteamNetworkingConfigValue)8, (ESteamNetworkingConfigDataType)1, ((BaseUnityPlugin)this).Config.Bind<int>("Network", "PacketReorderTime", 20, (ConfigDescription)null).Value);
			SetSteamNetworkValue((ESteamNetworkingConfigValue)26, (ESteamNetworkingConfigDataType)3, ((BaseUnityPlugin)this).Config.Bind<float>("Network", "PacketDuplicatePercentSend", 0.1f, (ConfigDescription)null).Value);
			SetSteamNetworkValue((ESteamNetworkingConfigValue)26, (ESteamNetworkingConfigDataType)3, ((BaseUnityPlugin)this).Config.Bind<float>("Network", "PacketDuplicatePercentReceive", 0.1f, (ConfigDescription)null).Value);
			SetSteamNetworkValue((ESteamNetworkingConfigValue)28, (ESteamNetworkingConfigDataType)1, ((BaseUnityPlugin)this).Config.Bind<int>("Network", "PacketDuplicateTimeMax", 60, (ConfigDescription)null).Value);
		}

		private static void SetSteamNetworkValue<T>(ESteamNetworkingConfigValue name, ESteamNetworkingConfigDataType type, T value) where T : unmanaged
		{
			//IL_000e: 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)
			GCHandle gCHandle = GCHandle.Alloc(value, GCHandleType.Pinned);
			SteamNetworkingUtils.SetConfigValue(name, (ESteamNetworkingConfigScope)1, IntPtr.Zero, type, gCHandle.AddrOfPinnedObject());
			gCHandle.Free();
		}
	}
	public class PrefabSpawner : MonoBehaviour
	{
		public enum EnemyType
		{
			Unknown,
			Archer,
			Catapult,
			Crossbow,
			Exploder,
			Flyer,
			Hunterling,
			Melee,
			MonsterRider,
			Ogre,
			ProjectileBow,
			Racer,
			Slime,
			StrongSlime,
			Weakling
		}

		private readonly Dictionary<string, EnemyType> _enemyNameToType = new Dictionary<string, EnemyType>();

		private readonly Dictionary<EnemyType, string> _enemyTypeToName = new Dictionary<EnemyType, string>();

		private readonly Dictionary<EnemyType, GameObject> _prefabs = new Dictionary<EnemyType, GameObject>();

		private void Awake()
		{
			AddEnemyEntries(EnemyType.Unknown, "");
			AddEnemyEntries(EnemyType.Archer, "E Archer");
			AddEnemyEntries(EnemyType.Catapult, "E Catapult");
			AddEnemyEntries(EnemyType.Crossbow, "E Crossbow");
			AddEnemyEntries(EnemyType.Exploder, "E Exploder");
			AddEnemyEntries(EnemyType.Flyer, "E Flyer");
			AddEnemyEntries(EnemyType.Hunterling, "E Hunterling");
			AddEnemyEntries(EnemyType.Melee, "E Melee");
			AddEnemyEntries(EnemyType.MonsterRider, "E MonsterRider");
			AddEnemyEntries(EnemyType.Ogre, "E Ogre");
			AddEnemyEntries(EnemyType.ProjectileBow, "E ProjectileBow");
			AddEnemyEntries(EnemyType.Racer, "E Racer");
			AddEnemyEntries(EnemyType.Slime, "E Slime");
			AddEnemyEntries(EnemyType.StrongSlime, "E StrongSlime");
			AddEnemyEntries(EnemyType.Weakling, "E Weakling");
		}

		private void AddEnemyEntries(EnemyType type, string enemy)
		{
			_enemyTypeToName.Add(type, enemy);
			_enemyNameToType.Add(enemy, type);
		}

		private GameObject GetPrefab(EnemyType type)
		{
			if (!_prefabs.TryGetValue(type, out var value) || (Object)(object)value == (Object)null)
			{
				value = GameObject.Find(_enemyTypeToName[type]);
				_prefabs.Add(type, value);
			}
			return value;
		}

		public EnemyType ToEnemy(string enemy)
		{
			EnemyType value;
			return _enemyNameToType.TryGetValue(enemy, out value) ? value : EnemyType.Unknown;
		}

		public GameObject Spawn(ushort id, EnemyType type)
		{
			GameObject prefab = GetPrefab(type);
			if ((Object)(object)prefab == (Object)null)
			{
				return null;
			}
			GameObject val = Helpers.InstantiateDisabled<GameObject>(prefab, (Transform)null, worldPositionStays: false);
			Identifier identifier = val.AddComponent<Identifier>();
			identifier.SetIdentity(IdentifierType.Enemy, id);
			return val;
		}
	}
	public class TextureRepository
	{
		public readonly Texture2D Crown = LoadTexture("crown.png");

		public readonly Texture2D Lock = LoadTexture("lock-icon.png");

		public readonly Texture2D Blank = LoadTexture("blank.png");

		private static Texture2D LoadTexture(string textureName)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = executingAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith(textureName));
			Stream manifestResourceStream = executingAssembly.GetManifestResourceStream(name);
			Texture2D val = new Texture2D(2, 2, (GraphicsFormat)8, 1, (TextureCreationFlags)0);
			using MemoryStream memoryStream = new MemoryStream();
			manifestResourceStream.CopyTo(memoryStream);
			ImageConversion.LoadImage(val, memoryStream.ToArray());
			return val;
		}
	}
}
namespace ThronefallMP.Utils
{
	public static class Ext
	{
		public static bool LogErrorFiltered(string section)
		{
			return ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("Debug", "ShowError" + section, true, (ConfigDescription)null).Value;
		}

		public static void LogErrorFiltered(this ManualLogSource source, string section, object obj)
		{
			ConfigEntry<bool> val = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("Debug", "ShowError" + section, true, (ConfigDescription)null);
			if (val.Value)
			{
				source.LogError((object)(section + "> " + obj));
			}
		}

		public static bool LogWarningFiltered(string section)
		{
			return ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("Debug", "ShowWarning" + section, true, (ConfigDescription)null).Value;
		}

		public static void LogWarningFiltered(this ManualLogSource source, string section, object obj)
		{
			ConfigEntry<bool> val = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("Debug", "ShowWarning" + section, true, (ConfigDescription)null);
			if (val.Value)
			{
				source.LogWarning((object)(section + "> " + obj));
			}
		}

		public static bool LogInfoFiltered(string section)
		{
			return ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("Debug", "ShowInfo" + section, true, (ConfigDescription)null).Value;
		}

		public static void LogInfoFiltered(this ManualLogSource source, string section, object obj)
		{
			ConfigEntry<bool> val = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("Debug", "ShowInfo" + section, true, (ConfigDescription)null);
			if (val.Value)
			{
				source.LogInfo((object)(section + "> " + obj));
			}
		}

		public static bool LogDebugFiltered(string section)
		{
			return ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("Debug", "ShowDebug" + section, true, (ConfigDescription)null).Value;
		}

		public static void LogDebugFiltered(this ManualLogSource source, string section, object obj)
		{
			ConfigEntry<bool> val = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("Debug", "ShowDebug" + section, true, (ConfigDescription)null);
			if (val.Value)
			{
				source.LogDebug(obj);
			}
		}
	}
	[Serializable]
	public struct Half : IComparable, IFormattable, IConvertible, IComparable<Half>, IEquatable<Half>
	{
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		internal ushort value;

		public static readonly Half Epsilon = ToHalf(1);

		public static readonly Half MaxValue = ToHalf(31743);

		public static readonly Half MinValue = ToHalf(64511);

		public static readonly Half NaN = ToHalf(65024);

		public static readonly Half NegativeInfinity = ToHalf(64512);

		public static readonly Half PositiveInfinity = ToHalf(31744);

		public Half(float value)
		{
			this = HalfHelper.SingleToHalf(value);
		}

		public Half(int value)
			: this((float)value)
		{
		}

		public Half(long value)
			: this((float)value)
		{
		}

		public Half(double value)
			: this((float)value)
		{
		}

		public Half(decimal value)
			: this((float)value)
		{
		}

		public Half(uint value)
			: this((float)value)
		{
		}

		public Half(ulong value)
			: this((float)value)
		{
		}

		public static Half Negate(Half half)
		{
			return -half;
		}

		public static Half Add(Half half1, Half half2)
		{
			return half1 + half2;
		}

		public static Half Subtract(Half half1, Half half2)
		{
			return half1 - half2;
		}

		public static Half Multiply(Half half1, Half half2)
		{
			return half1 * half2;
		}

		public static Half Divide(Half half1, Half half2)
		{
			return half1 / half2;
		}

		public static Half operator +(Half half)
		{
			return half;
		}

		public static Half operator -(Half half)
		{
			return HalfHelper.Negate(half);
		}

		public static Half operator ++(Half half)
		{
			return (Half)((float)half + 1f);
		}

		public static Half operator --(Half half)
		{
			return (Half)((float)half - 1f);
		}

		public static Half operator +(Half half1, Half half2)
		{
			return (Half)((float)half1 + (float)half2);
		}

		public static Half operator -(Half half1, Half half2)
		{
			return (Half)((float)half1 - (float)half2);
		}

		public static Half operator *(Half half1, Half half2)
		{
			return (Half)((float)half1 * (float)half2);
		}

		public static Half operator /(Half half1, Half half2)
		{
			return (Half)((float)half1 / (float)half2);
		}

		public static bool operator ==(Half half1, Half half2)
		{
			return !IsNaN(half1) && half1.value == half2.value;
		}

		public static bool operator !=(Half half1, Half half2)
		{
			return half1.value != half2.value;
		}

		public static bool operator <(Half half1, Half half2)
		{
			return (float)half1 < (float)half2;
		}

		public static bool operator >(Half half1, Half half2)
		{
			return (float)half1 > (float)half2;
		}

		public static bool operator <=(Half half1, Half half2)
		{
			return half1 == half2 || half1 < half2;
		}

		public static bool operator >=(Half half1, Half half2)
		{
			return half1 == half2 || half1 > half2;
		}

		public static implicit operator Half(byte value)
		{
			return new Half((float)(int)value);
		}

		public static implicit operator Half(short value)
		{
			return new Half((float)value);
		}

		public static implicit operator Half(char value)
		{
			return new Half((float)(int)value);
		}

		public static implicit operator Half(int value)
		{
			return new Half((float)value);
		}

		public static implicit operator Half(long value)
		{
			return new Half((float)value);
		}

		public static explicit operator Half(float value)
		{
			return new Half(value);
		}

		public static explicit operator Half(double value)
		{
			return new Half((float)value);
		}

		public static explicit operator Half(decimal value)
		{
			return new Half((float)value);
		}

		public static explicit operator byte(Half value)
		{
			return (byte)(float)value;
		}

		public static explicit operator char(Half value)
		{
			return (char)(float)value;
		}

		public static explicit operator short(Half value)
		{
			return (short)(float)value;
		}

		public static explicit operator int(Half value)
		{
			return (int)(float)value;
		}

		public static explicit operator long(Half value)
		{
			return (long)(float)value;
		}

		public static implicit operator float(Half value)
		{
			return HalfHelper.HalfToSingle(value);
		}

		public static implicit operator double(Half value)
		{
			return (float)value;
		}

		public static explicit operator decimal(Half value)
		{
			return (decimal)(float)value;
		}

		public static implicit operator Half(sbyte value)
		{
			return new Half((float)value);
		}

		public static implicit operator Half(ushort value)
		{
			return new Half((float)(int)value);
		}

		public static implicit operator Half(uint value)
		{
			return new Half((float)value);
		}

		public static implicit operator Half(ulong value)
		{
			return new Half((float)value);
		}

		public static explicit operator sbyte(Half value)
		{
			return (sbyte)(float)value;
		}

		public static explicit operator ushort(Half value)
		{
			return (ushort)(float)value;
		}

		public static explicit operator uint(Half value)
		{
			return (uint)(float)value;
		}

		public static explicit operator ulong(Half value)
		{
			return (ulong)(float)value;
		}

		public int CompareTo(Half other)
		{
			int result = 0;
			if (this < other)
			{
				result = -1;
			}
			else if (this > other)
			{
				result = 1;
			}
			else if (this != other)
			{
				if (!IsNaN(this))
				{
					result = 1;
				}
				else if (!IsNaN(other))
				{
					result = -1;
				}
			}
			return result;
		}

		public int CompareTo(object obj)
		{
			int num = 0;
			if (obj == null)
			{
				return 1;
			}
			if (obj is Half)
			{
				return CompareTo((Half)obj);
			}
			throw new ArgumentException("Object must be of type Half.");
		}

		public bool Equals(Half other)
		{
			return other == this || (IsNaN(other) && IsNaN(this));
		}

		public override bool Equals(object obj)
		{
			bool result = false;
			if (obj is Half half && (half == this || (IsNaN(half) && IsNaN(this))))
			{
				result = true;
			}
			return result;
		}

		public override int GetHashCode()
		{
			return value.GetHashCode();
		}

		public TypeCode GetTypeCode()
		{
			return (TypeCode)255;
		}

		public static byte[] GetBytes(Half value)
		{
			return BitConverter.GetBytes(value.value);
		}

		public static ushort GetBits(Half value)
		{
			return value.value;
		}

		public static Half ToHalf(byte[] value, int startIndex)
		{
			return ToHalf((ushort)BitConverter.ToInt16(value, startIndex));
		}

		public static Half ToHalf(ushort bits)
		{
			return new Half
			{
				value = bits
			};
		}

		public static int Sign(Half value)
		{
			if (value < 0)
			{
				return -1;
			}
			if (value > 0)
			{
				return 1;
			}
			if (value != 0)
			{
				throw new ArithmeticException("Function does not accept floating point Not-a-Number values.");
			}
			return 0;
		}

		public static Half Abs(Half value)
		{
			return HalfHelper.Abs(value);
		}

		public static Half Max(Half value1, Half value2)
		{
			return (value1 < value2) ? value2 : value1;
		}

		public static Half Min(Half value1, Half value2)
		{
			return (value1 < value2) ? value1 : value2;
		}

		public static bool IsNaN(Half half)
		{
			return HalfHelper.IsNaN(half);
		}

		public static bool IsInfinity(Half half)
		{
			return HalfHelper.IsInfinity(half);
		}

		public static bool IsNegativeInfinity(Half half)
		{
			return HalfHelper.IsNegativeInfinity(half);
		}

		public static bool IsPositiveInfinity(Half half)
		{
			return HalfHelper.IsPositiveInfinity(half);
		}

		public static Half Parse(string value)
		{
			return (Half)float.Parse(value, CultureInfo.InvariantCulture);
		}

		public static Half Parse(string value, IFormatProvider provider)
		{
			return (Half)float.Parse(value, provider);
		}

		public static Half Parse(string value, NumberStyles style)
		{
			return (Half)float.Parse(value, style, CultureInfo.InvariantCulture);
		}

		public static Half Parse(string value, NumberStyles style, IFormatProvider provider)
		{
			return (Half)float.Parse(value, style, provider);
		}

		public static bool TryParse(string value, out Half result)
		{
			if (float.TryParse(value, out var result2))
			{
				result = (Half)result2;
				return true;
			}
			result = default(Half);
			return false;
		}

		public static bool TryParse(string value, NumberStyles style, IFormatProvider provider, out Half result)
		{
			bool result2 = false;
			if (float.TryParse(value, style, provider, out var result3))
			{
				result = (Half)result3;
				result2 = true;
			}
			else
			{
				result = default(Half);
			}
			return result2;
		}

		public override string ToString()
		{
			return ((float)this).ToString(CultureInfo.InvariantCulture);
		}

		public string ToString(IFormatProvider formatProvider)
		{
			return ((float)this).ToString(formatProvider);
		}

		public string ToString(string format)
		{
			return ((float)this).ToString(format, CultureInfo.InvariantCulture);
		}

		public string ToString(string format, IFormatProvider formatProvider)
		{
			return ((float)this).ToString(format, formatProvider);
		}

		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return this;
		}

		TypeCode IConvertible.GetTypeCode()
		{
			return GetTypeCode();
		}

		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return Convert.ToBoolean(this);
		}

		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return Convert.ToByte(this);
		}

		char IConvertible.ToChar(IFormatProvider provider)
		{
			throw new InvalidCastException(string.Format(CultureInfo.CurrentCulture, "Invalid cast from '{0}' to '{1}'.", "Half", "Char"));
		}

		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			throw new InvalidCastException(string.Format(CultureInfo.CurrentCulture, "Invalid cast from '{0}' to '{1}'.", "Half", "DateTime"));
		}

		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return Convert.ToDecimal(this);
		}

		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return Convert.ToDouble(this);
		}

		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return Convert.ToInt16(this);
		}

		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return Convert.ToInt32(this);
		}

		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return Convert.ToInt64(this);
		}

		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return Convert.ToSByte(this);
		}

		string IConvertible.ToString(IFormatProvider provider)
		{
			return Convert.ToString(this, CultureInfo.InvariantCulture);
		}

		object IConvertible.ToType(Type conversionType, IFormatProvider provider)
		{
			return ((IConvertible)(float)this).ToType(conversionType, provider);
		}

		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return Convert.ToUInt16(this);
		}

		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return Convert.ToUInt32(this);
		}

		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return Convert.ToUInt64(this);
		}
	}
	[ComVisible(false)]
	internal static class HalfHelper
	{
		private static readonly uint[] mantissaTable = GenerateMantissaTable();

		private static readonly uint[] exponentTable = GenerateExponentTable();

		private static readonly ushort[] offsetTable = GenerateOffsetTable();

		private static readonly ushort[] baseTable = GenerateBaseTable();

		private static readonly sbyte[] shiftTable = GenerateShiftTable();

		private static uint ConvertMantissa(int i)
		{
			uint num = (uint)(i << 13);
			uint num2 = 0u;
			while ((num & 0x800000) == 0)
			{
				num2 -= 8388608;
				num <<= 1;
			}
			num &= 0xFF7FFFFFu;
			num2 += 947912704;
			return num | num2;
		}

		private static uint[] GenerateMantissaTable()
		{
			uint[] array = new uint[2048];
			array[0] = 0u;
			for (int i = 1; i < 1024; i++)
			{
				array[i] = ConvertMantissa(i);
			}
			for (int j = 1024; j < 2048; j++)
			{
				array[j] = (uint)(939524096 + (j - 1024 << 13));
			}
			return array;
		}

		private static uint[] GenerateExponentTable()
		{
			uint[] array = new uint[64];
			array[0] = 0u;
			for (int i = 1; i < 31; i++)
			{
				array[i] = (uint)(i << 23);
			}
			array[31] = 1199570944u;
			array[32] = 2147483648u;
			for (int j = 33; j < 63; j++)
			{
				array[j] = (uint)(2147483648u + (j - 32 << 23));
			}
			array[63] = 3347054592u;
			return array;
		}

		private static ushort[] GenerateOffsetTable()
		{
			ushort[] array = new ushort[64];
			array[0] = 0;
			for (int i = 1; i < 32; i++)
			{
				array[i] = 1024;
			}
			array[32] = 0;
			for (int j = 33; j < 64; j++)
			{
				array[j] = 1024;
			}
			return array;
		}

		private static ushort[] GenerateBaseTable()
		{
			ushort[] array = new ushort[512];
			for (int i = 0; i < 256; i++)
			{
				sbyte b = (sbyte)(127 - i);
				if (b > 24)
				{
					array[i | 0] = 0;
					array[i | 0x100] = 32768;
				}
				else if (b > 14)
				{
					array[i | 0] = (ushort)(1024 >> 18 + b);
					array[i | 0x100] = (ushort)((1024 >> 18 + b) | 0x8000);
				}
				else if (b >= -15)
				{
					array[i | 0] = (ushort)(15 - b << 10);
					array[i | 0x100] = (ushort)((15 - b << 10) | 0x8000);
				}
				else if (b > sbyte.MinValue)
				{
					array[i | 0] = 31744;
					array[i | 0x100] = 64512;
				}
				else
				{
					array[i | 0] = 31744;
					array[i | 0x100] = 64512;
				}
			}
			return array;
		}

		private static sbyte[] GenerateShiftTable()
		{
			sbyte[] array = new sbyte[512];
			for (int i = 0; i < 256; i++)
			{
				sbyte b = (sbyte)(127 - i);
				if (b > 24)
				{
					array[i | 0] = 24;
					array[i | 0x100] = 24;
				}
				else if (b > 14)
				{
					array[i | 0] = (sbyte)(b - 1);
					array[i | 0x100] = (sbyte)(b - 1);
				}
				else if (b >= -15)
				{
					array[i | 0] = 13;
					array[i | 0x100] = 13;
				}
				else if (b > sbyte.MinValue)
				{
					array[i | 0] = 24;
					array[i | 0x100] = 24;
				}
				else
				{
					array[i | 0] = 13;
					array[i | 0x100] = 13;
				}
			}
			return array;
		}

		public unsafe static float HalfToSingle(Half half)
		{
			uint num = mantissaTable[offsetTable[half.value >> 10] + (half.value & 0x3FF)] + exponentTable[half.value >> 10];
			return *(float*)(&num);
		}

		public unsafe static Half SingleToHalf(float single)
		{
			uint num = *(uint*)(&single);
			ushort bits = (ushort)(baseTable[(num >> 23) & 0x1FF] + ((num & 0x7FFFFF) >> (int)shiftTable[num >> 23]));
			return Half.ToHalf(bits);
		}

		public static Half Negate(Half half)
		{
			return Half.ToHalf((ushort)(half.value ^ 0x8000));
		}

		public static Half Abs(Half half)
		{
			return Half.ToHalf((ushort)(half.value & 0x7FFF));
		}

		public static bool IsNaN(Half half)
		{
			return (half.value & 0x7FFF) > 31744;
		}

		public static bool IsInfinity(Half half)
		{
			return (half.value & 0x7FFF) == 31744;
		}

		public static bool IsPositiveInfinity(Half half)
		{
			return half.value == 31744;
		}

		public static bool IsNegativeInfinity(Half half)
		{
			return half.value == 64512;
		}
	}
	public static class Helpers
	{
		public const float Epsilon = 1.8E-43f;

		public const float EpsilonSqr = 9E-44f;

		public const float PositionEpsilonSqr = 0.0025f;

		private const float SpawnRadiusIncrement = 5f;

		private const int SpawnAngleIncrement = 60;

		private const int SpawnAngleEvenOffset = 30;

		public static Vector3 GetSpawnLocation(Vector3 position, int playerId)
		{
			//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_008f: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if (playerId == -1)
			{
				return position;
			}
			float num = 5f;
			int num2 = 0;
			bool flag = false;
			while (playerId > 0)
			{
				num2 += 60;
				if (num2 >= 360)
				{
					num2 = 0;
					num += 5f;
					flag = !flag;
				}
				playerId--;
			}
			Vector3 val = new Vector3
			{
				x = num
			};
			val = Quaternion.AngleAxis((float)(num2 + (flag ? 30 : 0)), Vector3.up) * val;
			return position + val;
		}

		public static string GetPath(Transform tr)
		{
			Transform parent = tr.parent;
			return ((Object)(object)parent == (Object)null) ? ((Object)tr).name : (GetPath(parent) + "/" + ((Object)tr).name);
		}

		public static bool UnityNullCheck(object a)
		{
			int result;
			if (a != null)
			{
				Object val = (Object)((a is Object) ? a : null);
				result = ((val == null || val != (Object)null) ? 1 : 0);
			}
			else
			{
				result = 0;
			}
			return (byte)result != 0;
		}

		public static PlayerInteraction FindClosest(PlayerInteraction[] players, Vector3 pos)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			float num = float.MaxValue;
			PlayerInteraction result = null;
			foreach (PlayerInteraction val in players)
			{
				Vector3 val2 = ((Component)val).transform.position - pos;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
					result = val;
				}
			}
			return result;
		}

		public static T InstantiateDisabled<T>(T original, Transform parent = null, bool worldPositionStays = false) where T : Object
		{
			if (!GetActiveState(original))
			{
				return Object.Instantiate<T>(original, parent, worldPositionStays);
			}
			(GameObject coreObject, Transform coreObjectTransform) tuple = CreateDisabledCoreObject(parent);
			GameObject item = tuple.coreObject;
			Transform item2 = tuple.coreObjectTransform;
			T val = Object.Instantiate<T>(original, item2, worldPositionStays);
			SetActiveState(val, state: false);
			SetParent(val, parent, worldPositionStays);
			Object.Destroy((Object)(object)item);
			return val;
		}

		public static T InstantiateDisabled<T>(T original, Vector3 position, Quaternion rotation, Transform parent = null) where T : Object
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (!GetActiveState(original))
			{
				return Object.Instantiate<T>(original, position, rotation, parent);
			}
			(GameObject coreObject, Transform coreObjectTransform) tuple = CreateDisabledCoreObject(parent);
			GameObject item = tuple.coreObject;
			Transform item2 = tuple.coreObjectTransform;
			T val = Object.Instantiate<T>(original, position, rotation, item2);
			SetActiveState(val, state: false);
			SetParent(val, parent, worldPositionStays: false);
			Object.Destroy((Object)(object)item);
			return val;
		}

		private static (GameObject coreObject, Transform coreObjectTransform) CreateDisabledCoreObject(Transform parent = null)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject(string.Empty);
			val.SetActive(false);
			Transform transform = val.transform;
			transform.SetParent(parent);
			return (coreObject: val, coreObjectTransform: transform);
		}

		private static bool GetActiveState<T>(T @object) where T : Object
		{
			object obj = @object;
			GameObject val = (GameObject)((obj is GameObject) ? obj : null);
			if (val != null)
			{
				return val.activeSelf;
			}
			object obj2 = @object;
			Component val2 = (Component)((obj2 is Component) ? obj2 : null);
			if (val2 != null)
			{
				return val2.gameObject.activeSelf;
			}
			return false;
		}

		private static void SetActiveState<T>(T @object, bool state) where T : Object
		{
			object obj = @object;
			GameObject val = (GameObject)((obj is GameObject) ? obj : null);
			if (val == null)
			{
				object obj2 = @object;
				Component val2 = (Component)((obj2 is Component) ? obj2 : null);
				if (val2 != null)
				{
					val2.gameObject.SetActive(state);
				}
			}
			else
			{
				val.SetActive(state);
			}
		}

		private static void SetParent<T>(T @object, Transform parent, bool worldPositionStays) where T : Object
		{
			object obj = @object;
			GameObject val = (GameObject)((obj is GameObject) ? obj : null);
			if (val == null)
			{
				object obj2 = @object;
				Component val2 = (Component)((obj2 is Component) ? obj2 : null);
				if (val2 != null)
				{
					val2.transform.SetParent(parent, worldPositionStays);
				}
			}
			else
			{
				val.transform.SetParent(parent, worldPositionStays);
			}
		}
	}
}
namespace ThronefallMP.UI
{
	public abstract class BaseUI : MonoBehaviour
	{
		public Canvas Canvas { get; set; }

		public GameObject PanelRoot { get; set; }

		public bool Enabled
		{
			get
			{
				return PanelRoot.activeSelf;
			}
			set
			{
				PanelRoot.SetActive(value);
			}
		}

		public abstract string Name { get; }

		public abstract void ConstructPanelContent();

		public static T Create<T>(GameObject canvas, GameObject container) where T : BaseUI
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0086: 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_00b2: 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)
			GameObject val = new GameObject("Temp", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(container.transform, false);
			T val2 = val.AddComponent<T>();
			val2.Canvas = canvas.GetComponent<Canvas>();
			val2.PanelRoot = val;
			((Object)val2.PanelRoot).name = val2.Name;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			component.offsetMin = new Vector2(0f, 0f);
			component.offsetMax = new Vector2(0f, 0f);
			val2.ConstructPanelContent();
			val2.Enabled = false;
			return val2;
		}
	}
	public static class LoadoutFrames
	{
		private static bool _resolved;

		private static UIFrame _levelSelect;

		private static readonly List<LoadoutUIHelper> _loadoutHelpers;

		public static UIFrame PrimaryGridFrame
		{
			get
			{
				Resolve();
				foreach (LoadoutUIHelper loadoutHelper in _loadoutHelpers)
				{
					if ((Object)(object)loadoutHelper != (Object)null && (Object)(object)loadoutHelper.frame != (Object)null)
					{
						return loadoutHelper.frame;
					}
				}
				return _levelSelect;
			}
		}

		public static UIFrame GridFrame
		{
			get
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Invalid comparison between Unknown and I4
				Resolve();
				foreach (LoadoutUIHelper loadoutHelper in _loadoutHelpers)
				{
					if ((Object)(object)loadoutHelper != (Object)null && (Object)(object)loadoutHelper.frame != (Object)null && (int)loadoutHelper.mode == 0)
					{
						return loadoutHelper.frame;
					}
				}
				return null;
			}
		}

		public static bool PopupOpen => SceneTransitionManagerPatch.InLevelSelect && (Object)(object)UIFrameManager.instance != (Object)null && IsPopupFrame(UIFrameManager.instance.ActiveFrame);

		static LoadoutFrames()
		{
			_loadoutHelpers = new List<LoadoutUIHelper>();
			SceneManager.sceneLoaded += delegate
			{
				Invalidate();
			};
		}

		public static void Invalidate()
		{
			_resolved = false;
			_levelSelect = null;
			_loadoutHelpers.Clear();
		}

		private static void Resolve()
		{
			if (_resolved || (Object)(object)UIFrameManager.instance == (Object)null)
			{
				return;
			}
			_levelSelect = Traverse.Create((object)UIFrameManager.instance).Field<UIFrame>("levelSelectFrame").Value;
			LoadoutUIHelper[] array = Object.FindObjectsOfType<LoadoutUIHelper>(true);
			foreach (LoadoutUIHelper val in array)
			{
				if (!val.inMatch && (Object)(object)val.frame != (Object)null)
				{
					_loadoutHelpers.Add(val);
				}
			}
			_resolved = true;
		}

		public static bool IsPopupFrame(UIFrame frame)
		{
			if ((Object)(object)frame == (Object)null)
			{
				return false;
			}
			Resolve();
			if ((Object)(object)frame == (Object)(object)_levelSelect)
			{
				return true;
			}
			foreach (LoadoutUIHelper loadoutHelper in _loadoutHelpers)
			{
				if ((Object)(object)loadoutHelper != (Object)null && (Object)(object)loadoutHelper.frame == (Object)(object)frame)
				{
					return true;
				}
			}
			return false;
		}

		public static LoadoutUIHelper HelperFor(UIFrame frame)
		{
			if ((Object)(object)frame == (Object)null)
			{
				return null;
			}
			Resolve();
			foreach (LoadoutUIHelper loadoutHelper in _loadoutHelpers)
			{
				if ((Object)(object)loadoutHelper != (Object)null && (Object)(object)loadoutHelper.frame == (Object)(object)frame)
				{
					return loadoutHelper;
				}
			}
			return null;
		}

		public static string DebugState()
		{
			Resolve();
			UIFrame val = (((Object)(object)UIFrameManager.instance != (Object)null) ? UIFrameManager.instance.ActiveFrame : null);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(string.Format("resolved={0} levelSelect={1} ", _resolved, ((Object)(object)_levelSelect != (Object)null) ? ((Object)_levelSelect).name : "null"));
			stringBuilder.Append(string.Format("helpers={0} activeFrame={1}", _loadoutHelpers.Count, ((Object)(object)val != (Object)null) ? ((Object)val).name : "null"));
			return stringBuilder.ToString();
		}

		public static void CloseAllPopupFrames()
		{
			UIFrameManager instance = UIFrameManager.instance;
			for (int i = 0; i < 4; i++)
			{
				if (!((Object)(object)instance != (Object)null))
				{
					break;
				}
				if (!IsPopupFrame(instance.ActiveFrame))
				{
					break;
				}
				LoadoutUIHelper val = HelperFor(instance.ActiveFrame);
				if ((Object)(object)val != (Object)null)
				{
					ResetLoadoutOnCancel componentInChildren = ((Component)val).GetComponentInChildren<ResetLoadoutOnCancel>(true);
					if ((Object)(object)componentInChildren != (Object)null)
					{
						componentInChildren.LockInLoadout();
					}
				}
				instance.CloseActiveFrame();
			}
		}
	}
	public static class LoadoutStatusStrip
	{
		private static GameObject _root;

		private static TextMeshProUGUI _text;

		public static void Show()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0081: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root == (Object)null)
			{
				UIFrame primaryGridFrame = LoadoutFrames.PrimaryGridFrame;
				if ((Object)(object)primaryGridFrame == (Object)null)
				{
					return;
				}
				_root = new GameObject("MP Loadout Status", new Type[1] { typeof(RectTransform) });
				_root.transform.SetParent(((Component)primaryGridFrame).transform, false);
				RectTransform val = (RectTransform)_root.transform;
				val.anchorMin = new Vector2(0.5f, 0f);
				val.anchorMax = new Vector2(0.5f, 0f);
				val.pivot = new Vector2(0.5f, 0f);
				val.anchoredPosition = new Vector2(0f, 24f);
				val.sizeDelta = new Vector2(1400f, 40f);
				_text = _root.AddComponent<TextMeshProUGUI>();
				TMP_Text componentInChildren = ((Component)primaryGridFrame).GetComponentInChildren<TMP_Text>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((TMP_Text)_text).font = componentInChildren.font;
				}
				((TMP_Text)_text).fontSize = 24f;
				((TMP_Text)_text).alignment = (TextAlignmentOptions)514;
				((Graphic)_text).color = Color.white;
				((Graphic)_text).raycastTarget = false;
			}
			_root.SetActive(true);
		}

		public static void Hide()
		{
			if ((Object)(object)_root != (Object)null)
			{
				_root.SetActive(false);
			}
		}

		public static void SetText(string value)
		{
			if ((Object)(object)_text != (Object)null)
			{
				((TMP_Text)_text).text = value;
			}
		}
	}
	public static class UIHelper
	{
		public static GameObject CreateBox(GameObject root, string name, Color color)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIObject(name, root);
			bool? childControlWidth = true;
			bool? childControlHeight = true;
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val, (bool?)null, (bool?)null, childControlWidth, childControlHeight, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (TextAnchor?)null);
			Image val2 = val.AddComponent<Image>();
			val2.type = (Type)1;
			((Graphic)val2).color = color;
			return val;
		}

		public static TextMeshProUGUI CreateText(GameObject root, string name, string text, TMP_FontAsset font = null)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIObject(name, root);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).text = text;
			((Graphic)val2).color = UIManager.TextColor;
			((TMP_Text)val2).font = (Object.op_Implicit((Object)(object)font) ? font : UIManager.DefaultFont);
			((TMP_Text)val2).fontSize = 24f;
			((TMP_Text)val2).alignment = (TextAlignmentOptions)514;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.sizeDelta = Vector2.zero;
			return val2;
		}

		public static ButtonControl CreateButton(GameObject root, string name, string text)
		{
			//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)
			//IL_002c: 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_0056: 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_005f: 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_00a8: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			GameObject val = CreateUIObject(name, root, new Vector2(25f, 25f));
			GameObject val2 = CreateUIObject("text", val);
			Button button = val.AddComponent<Button>();
			Navigation navigation = ((Selectable)button).navigation;
			((Navigation)(ref navigation)).mode = (Mode)4;
			Navigation navigation2 = navigation;
			((Selectable)button).navigation = navigation2;
			TextMeshProUGUI val3 = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val3).text = text;
			((TMP_Text)val3).font = UIManager.DefaultFont;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)514;
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.sizeDelta = Vector2.zero;
			((UnityEvent)button.onClick).AddListener((UnityAction)delegate
			{
				((Selectable)button).OnDeselect((BaseEventData)null);
			});
			SetLayoutElement(val, 20, 20);
			val.AddComponent<EventTrigger>();
			return val.AddComponent<ButtonControl>();
		}

		public static GameObject CreateCheck(GameObject root, string name, bool startsOn = false)
		{
			//IL_000d: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_0091: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: 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)
			GameObject val = CreateUIObject(name, root, new Vector2(25f, 25f));
			Toggle val2 = val.AddComponent<Toggle>();
			((Graphic)val.AddComponent<Image>()).color = Color.clear;
			val2.isOn = startsOn;
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)10, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)3);
			Navigation navigation = ((Selectable)val2).navigation;
			((Navigation)(ref navigation)).mode = (Mode)4;
			Navigation navigation2 = navigation;
			((Selectable)val2).navigation = navigation2;
			GameObject val3 = CreateUIObject("checkmark", val);
			int? flexibleWidth = 0;
			int? flexibleHeight = 0;
			SetLayoutElement(val3, null, null, flexibleWidth, flexibleHeight);
			RectTransform component = CreateUIObject("background", val3).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.1f, 0.1f);
			component.anchorMax = new Vector2(0.9f, 0.9f);
			RectTransform component2 = CreateUIObject("check", val3).GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.3f, 0.3f);
			component2.anchorMax = new Vector2(0.7f, 0.7f);
			Image val4 = val3.gameObject.AddComponent<Image>();
			val4.type = (Type)1;
			val4 = ((Component)component).gameObject.AddComponent<Image>();
			val4.type = (Type)1;
			val4 = ((Component)component2).gameObject.AddComponent<Image>();
			val4.type = (Type)1;
			return val;
		}

		public static ToggleControl CreateLeftToggle(GameObject root, string name, string text, bool startsOn = false)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateCheck(root, name, startsOn);
			GameObject val2 = CreateUIObject("text", val);
			TextMeshProUGUI val3 = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val3).text = text;
			((TMP_Text)val3).font = UIManager.DefaultFont;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)513;
			ContentSizeFitter val4 = val2.AddComponent<ContentSizeFitter>();
			val4.horizontalFit = (FitMode)2;
			val4.verticalFit = (FitMode)2;
			SetLayoutElement(val, 20, 20);
			val.AddComponent<EventTrigger>();
			return val.AddComponent<ToggleControl>();
		}

		public static ToggleControl CreateRightToggle(GameObject root, string name, string text, bool startsOn = false)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateCheck(root, name, startsOn);
			GameObject val2 = CreateUIObject("text", val);
			TextMeshProUGUI val3 = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val3).text = text;
			((TMP_Text)val3).font = UIManager.DefaultFont;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)513;
			ContentSizeFitter val4 = val2.AddComponent<ContentSizeFitter>();
			val4.horizontalFit = (FitMode)2;
			val4.verticalFit = (FitMode)2;
			val2.transform.SetSiblingIndex(0);
			SetLayoutElement(val, 20, 20);
			val.AddComponent<EventTrigger>();
			return val.AddComponent<ToggleControl>();
		}

		public static ToggleControl CreateToggle(GameObject root, string name, bool startsOn = false)
		{
			GameObject val = CreateCheck(root, name, startsOn);
			SetLayoutElement(val, 20, 20);
			val.AddComponent<EventTrigger>();
			return val.AddComponent<ToggleControl>();
		}

		public static TMP_InputField CreateInputField(GameObject panel, string name, string label, string value, int? labelWidth = null, int limit = 32, TMP_FontAsset font = null)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Expected O, but got Unknown
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: 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_0321: 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_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateUIObject(name + "Group", panel);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val, (bool?)false, (bool?)false, (bool?)true, (bool?)false, (int?)20, (int?)5, (int?)5, (int?)5, (int?)5, (TextAnchor?)(TextAnchor)3);
			int? flexibleWidth = 1;
			SetLayoutElement(val, null, null, flexibleWidth);
			if (label != null)
			{
				GameObject val2 = CreateBox(val, name + "_label_bg", Color.clear);
				bool? childControlWidth = true;
				TextAnchor? childAlignment = (TextAnchor)3;
				UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val2, (bool?)null, (bool?)null, childControlWidth, (bool?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, childAlignment);
				GameObject gameObject = val2.gameObject;
				flexibleWidth = 0;
				SetLayoutElement(gameObject, labelWidth, null, flexibleWidth);
				val2.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
				TextMeshProUGUI val3 = CreateText(val2, name + "_label", label + ": ", font);
				((TMP_Text)val3).alignment = (TextAlignmentOptions)513;
			}
			GameObject val4 = CreateBox(val, name + "_bg", new Color(0.2f, 0.2f, 0.2f));
			flexibleWidth = 1;
			SetLayoutElement(val4, null, null, flexibleWidth);
			val4.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			TMP_InputField val5 = val4.AddComponent<TMP_InputField>();
			val5.textViewport = ((Component)((Component)val5).transform.parent).GetComponent<RectTransform>();
			((Selectable)val5).targetGraphic = (Graphic)(object)val4.GetComponent<Image>();
			GameObject val6 = new GameObject("area", new Type[1] { typeof(RectTransform) });
			val5.textViewport = val6.GetComponent<RectTransform>();
			val6.transform.SetParent(val4.transform);
			((Transform)val5.textViewport).localPosition = Vector3.zero;
			val5.textViewport.anchorMin = new Vector2(0f, 0f);
			val5.textViewport.anchorMax = new Vector2(1f, 1f);
			val6.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			TextMeshProUGUI val7 = CreateText(val6, name ?? "", value ?? "", font);
			((Graphic)val7).color = UIManager.TextColor;
			((TMP_Text)val7).fontSize = 20f;
			val5.textComponent = (TMP_Text)(object)val7;
			val5.text = ((TMP_Text)val7).text;
			val5.characterLimit = limit;
			RectTransform component = ((Component)val7).GetComponent<RectTransform>();
			((Transform)component).localPosition = Vector3.zero;
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			val5.onFocusSelectAll = false;
			return val5;
		}

		public static void AddEvent(GameObject button, EventTriggerType type, UnityAction<BaseEventData> action)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			EventTrigger component = button.GetComponent<EventTrigger>();
			TriggerEvent val = new TriggerEvent();
			((UnityEvent<BaseEventData>)(object)val).AddListener(action);
			component.triggers.Add(new Entry
			{
				eventID = type,
				callback = val
			});
		}

		public static T SetLayoutGroup<T>(GameObject gameObject, bool? forceWidth = null, bool? forceHeight = null, bool? childControlWidth = null, bool? childControlHeight = null, int? spacing = null, int? padTop = null, int? padBottom = null, int? padLeft = null, int? padRight = null, TextAnchor? childAlignment = null) where T : HorizontalOrVerticalLayoutGroup
		{
			T val = gameObject.GetComponent<T>();
			if (!Object.op_Implicit((Object)(object)val))
			{
				val = gameObject.AddComponent<T>();
			}
			return SetLayoutGroup(val, forceWidth, forceHeight, childControlWidth, childControlHeight, spacing, padTop, padBottom, padLeft, padRight, childAlignment);
		}

		public static T SetLayoutGroup<T>(T group, bool? forceWidth = null, bool? forceHeight = null, bool? childControlWidth = null, bool? childControlHeight = null, int? spacing = null, int? padTop = null, int? padBottom = null, int? padLeft = null, int? padRight = null, TextAnchor? childAlignment = null) where T : HorizontalOrVerticalLayoutGroup
		{
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			if (forceWidth.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)group).childForceExpandWidth = forceWidth.Value;
			}
			if (forceHeight.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)group).childForceExpandHeight = forceHeight.Value;
			}
			if (childControlWidth.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)(object)group).SetChildControlWidth(childControlWidth.Value);
			}
			if (childControlHeight.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)(object)group).SetChildControlHeight(childControlHeight.Value);
			}
			if (spacing.HasValue)
			{
				((HorizontalOrVerticalLayoutGroup)group).spacing = spacing.Value;
			}
			if (padTop.HasValue)
			{
				((LayoutGroup)(object)group).padding.top = padTop.Value;
			}
			if (padBottom.HasValue)
			{
				((LayoutGroup)(object)group).padding.bottom = padBottom.Value;
			}
			if (padLeft.HasValue)
			{
				((LayoutGroup)(object)group).padding.left = padLeft.Value;
			}
			if (padRight.HasValue)
			{
				((LayoutGroup)(object)group).padding.right = padRight.Value;
			}
			if (childAlignment.HasValue)
			{
				((LayoutGroup)(object)group).childAlignment = childAlignment.Value;
			}
			return group;
		}

		public static GameObject CreateUIObject(string name, GameObject parent, Vector2 sizeDelta = default(Vector2))
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name)
			{
				layer = 5,
				hideFlags = (HideFlags)61
			};
			if (Object.op_Implicit((Object)(object)parent))
			{
				val.transform.SetParent(parent.transform, false);
			}
			val.AddComponent<RectTransform>().sizeDelta = sizeDelta;
			return val;
		}

		public static LayoutElement SetLayoutElement(GameObject gameObject, int? minWidth = null, int? minHeight = null, int? flexibleWidth = null, int? flexibleHeight = null, int? preferredWidth = null, int? preferredHeight = null, bool? ignoreLayout = null)
		{
			LayoutElement val = gameObject.GetComponent<LayoutElement>();
			if (!Object.op_Implicit((Object)(object)val))
			{
				val = gameObject.AddComponent<LayoutElement>();
			}
			if (minWidth.HasValue)
			{
				val.minWidth = minWidth.Value;
			}
			if (minHeight.HasValue)
			{
				val.minHeight = minHeight.Value;
			}
			if (flexibleWidth.HasValue)
			{
				val.flexibleWidth = flexibleWidth.Value;
			}
			if (flexibleHeight.HasValue)
			{
				val.flexibleHeight = flexibleHeight.Value;
			}
			if (preferredWidth.HasValue)
			{
				val.preferredWidth = preferredWidth.Value;
			}
			if (preferredHeight.HasValue)
			{
				val.preferredHeight = preferredHeight.Value;
			}
			if (ignoreLayout.HasValue)
			{
				val.ignoreLayout = ignoreLayout.Value;
			}
			return val;
		}

		public static void SetChildControlHeight(this HorizontalOrVerticalLayoutGroup group, bool value)
		{
			group.childControlHeight = value;
		}

		public static void SetChildControlWidth(this HorizontalOrVerticalLayoutGroup group, bool value)
		{
			group.childControlWidth = value;
		}
	}
	public static class UIManager
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__34_0;

			internal void <Initialize>b__34_0()
			{
				LobbyListPanel.Open();
				TitleScreen.SetActive(false);
			}
		}

		public static bool ExitHandled = false;

		public static readonly Color DarkBackgroundColor = new Color(0.06f, 0.06f, 0.06f, 1f);

		public static readonly Color BackgroundColor = new Color(0.11f, 0.11f, 0.11f, 1f);

		public static readonly Color TransparentBackgroundColor = new Color(0f, 0f, 0f, 0.3f);

		public static readonly Color SelectedTransparentBackgroundColor = new Color(0.2f, 0.2f, 0.2f, 0.3f);

		public static readonly Color TextColor = new Color(0.78f, 0.65f, 0.46f, 1f);

		public static readonly Color ButtonTextColor = new Color(0.97f, 0.88f, 0.75f, 1f);

		public static readonly Color NoninteractiveButtonTextColor = new Color(0.3f, 0.3f, 0.4f, 1f);

		public static readonly Color ButtonHoverTextColor = new Color(0f, 0.41f, 0.11f);

		public static readonly Color ExitButtonColor = new Color(0.176f, 0.165f, 0.149f);

		public static TMP_FontAsset DefaultFont;

		private static bool _initialized;

		private static GameObject _canvas;

		private static GameObject _container;

		public static GameObject TitleScreen { get; private set; }

		public static LobbyListPanel LobbyListPanel { get; private set; }

		public static HostPanel HostPanel { get; private set; }

		public static ChatPanel ChatPanel { get; private set; }

		public static GameStatusPanel GameStatusPanel { get; private set; }

		public static void Initialize()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_008e: 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_00ba: 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_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Expected O, but got Unknown
			//IL_02b6: 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: Expected O, but got Unknown
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Expected O, but got Unknown
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: 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)
			if (_initialized)
			{
				return;
			}
			_canvas = GameObject.Find("UI Canvas");
			if ((Object)(object)_canvas.GetComponent<StandaloneInputModule>() == (Object)null)
			{
				_canvas.AddComponent<StandaloneInputModule>();
			}
			_container = new GameObject("Mod UI", new Type[1] { typeof(RectTransform) });
			RectTransform component = _container.GetComponent<RectTransform>();
			((Transform)component).SetParent(_canvas.transform, false);
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			component.offsetMin = new Vector2(0f, 0f);
			component.offsetMax = new Vector2(0f, 0f);
			TitleScreen = GameObject.Find("UI Canvas/Title Frame").gameObject;
			ThronefallUIElement component2 = ((Component)TitleScreen.transform.Find("Menu Items/Play")).GetComponent<ThronefallUIElement>();
			ThronefallUIElement component3 = ((Component)TitleScreen.transform.Find("Menu Items/Settings")).GetComponent<ThronefallUIElement>();
			DefaultFont = ((TMP_Text)((Component)component3).GetComponent<TextMeshProUGUI>()).font;
			LobbyListPanel = BaseUI.Create<LobbyListPanel>(_canvas, _container);
			HostPanel = BaseUI.Create<HostPanel>(_canvas, _container);
			ChatPanel = BaseUI.Create<ChatPanel>(_canvas, _container);
			GameStatusPanel = BaseUI.Create<GameStatusPanel>(_canvas, _container);
			ChatPanel.Enabled = true;
			GameStatusPanel.Enabled = true;
			GameObject val = Helpers.InstantiateDisabled<GameObject>(((Component)component3).gameObject, ((Component)component3).transform.parent, worldPositionStays: false);
			((Object)val).name = "Multiplayer";
			val.transform.SetSiblingIndex(1);
			Object.DestroyImmediate((Object)(object)val.GetComponent<Localize>());
			TextMeshProUGUI component4 = val.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component4).text = "Multiplayer";
			TFUITextButton component5 = val.GetComponent<TFUITextButton>();
			Traverse.Create((object)((ThronefallUIElement)component5).onSelectionStateChange).Field("m_PersistentCalls").Method("Clear", Array.Empty<object>())
				.GetValue();
			Traverse.Create((object)((ThronefallUIElement)component5).onApply).Field("m_PersistentCalls").Method("Clear", Array.Empty<object>())
				.GetValue();
			UnityEvent onApply = ((ThronefallUIElement)component5).onApply;
			object obj = <>c.<>9__34_0;
			if (obj == null)
			{
				UnityAction val2 = delegate
				{
					LobbyListPanel.Open();
					TitleScreen.SetActive(false);
				};
				<>c.<>9__34_0 = val2;
				obj = (object)val2;
			}
			onApply.AddListener((UnityAction)obj);
			((ThronefallUIElement)component5).rightNav = component3;
			if (SteamManager.Initialized)
			{
				component2.rightNav = (ThronefallUIElement)(object)component5;
				component3.leftNav = (ThronefallUIElement)(object)component5;
			}
			else
			{
				((ThronefallUIElement)component5).ignoreMouse = true;
				((ThronefallUIElement)component5).cannotBeSelected = true;
				((Graphic)component4).color = NoninteractiveButtonTextColor;
			}
			val.SetActive(true);
			GameObject val3 = new GameObject("MP Version", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(TitleScreen.transform, false);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = new Vector2(1f, 0f);
			val4.anchorMax = new Vector2(1f, 0f);
			val4.pivot = new Vector2(1f, 0f);
			val4.anchoredPosition = new Vector2(-18f, 14f);
			val4.sizeDelta = new Vector2(500f, 30f);
			TextMeshProUGUI val5 = val3.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val5).font = DefaultFont;
			((TMP_Text)val5).fontSize = 18f;
			((TMP_Text)val5).alignment = (TextAlignmentOptions)1028;
			((Graphic)val5).color = new Color(1f, 1f, 1f, 0.5f);
			((Graphic)val5).raycastTarget = false;
			((TMP_Text)val5).text = "Multiplayer v1.2.2";
			_initialized = true;
		}

		public static void CloseAllPanels()
		{
			LobbyListPanel.Enabled = false;
			HostPanel.Enabled = false;
		}

		public static WeaponDialog CreateWeaponDialog()
		{
			WeaponDialog weaponDialog = BaseUI.Create<WeaponDialog>(_canvas, _container);
			weaponDialog.Enabled = true;
			return weaponDialog;
		}

		public static PasswordDialog CreatePasswordDialog(PasswordDialog.Confirm confirm, PasswordDialog.Cancel cancel)
		{
			PasswordDialog passwordDialog = BaseUI.Create<PasswordDialog>(_canvas, _container);
			passwordDialog.OnConfirm = (PasswordDialog.Confirm)Delegate.Combine(passwordDialog.OnConfirm, confirm);
			passwordDialog.OnCancel = (PasswordDialog.Cancel)Delegate.Combine(passwordDialog.OnCancel, cancel);
			passwordDialog.Enabled = true;
			return passwordDialog;
		}

		public static MessageDialog CreateMessageDialog(string title, string message, string button = null, Color? color = null, MessageDialog.ClickDelegate onClick = null)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			MessageDialog messageDialog = BaseUI.Create<MessageDialog>(_canvas, _container);
			messageDialog.Title = title;
			messageDialog.Message = message;
			if (color.HasValue)
			{
				messageDialog.Color = color.Value;
			}
			if (button != null)
			{
				messageDialog.ButtonText = button;
			}
			if (onClick != null)
			{
				messageDialog.OnClick = (MessageDialog.ClickDelegate)Delegate.Combine(messageDialog.OnClick, onClick);
			}
			messageDialog.Enabled = true;
			return messageDialog;
		}
	}
}
namespace ThronefallMP.UI.Panels
{
	public class ChatPanel : BaseUI
	{
		private class Message
		{
			public GameObject Line;

			public TMP_Text Text;

			public float Time;

			public bool Faded;
		}

		private const int MaxLines = 8;

		private const float MessageTimeout = 3f;

		private const float MessageFadeTime = 0.5f;

		private static readonly Color BackgroundColor = new Color(0.07f, 0.07f, 0.07f, 1f);

		private static readonly Color InputColor = new Color(0.9f, 0.9f, 0.9f, 1f);

		private static readonly Color ChatColor = new Color(0.9f, 0.9f, 0.9f, 1f);

		private static readonly Color32 ChatBorderColor = new Color32((byte)0, (byte)0, (byte)0, byte.MaxValue);

		private GameObject _container;

		private GameObject _chatBoxContainer;

		private TMP_InputField _chatBox;

		private readonly List<Message> _lines = new List<Message>();

		private TMP_FontAsset _chatBoxFont;

		private TMP_FontAsset _chatFont;

		private bool _justClosed;

		public override string Name => "Chat Panel";

		private Font CreateFont()
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			Dictionary<string, int> dictionary = new Dictionary<string, int>
			{
				{ "arial", 0 },
				{ "times", 1 },
				{ "verdana", 2 },
				{ "cour", 3 }
			};
			int num = int.MaxValue;
			string text = Font.GetPathsToOSFonts()[0];
			string[] pathsToOSFonts = Font.GetPathsToOSFonts();
			foreach (string text2 in pathsToOSFonts)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text2);
				if (dictionary.TryGetValue(fileNameWithoutExtension, out var value) && value < num)
				{
					text = text2;
					num = value;
					if (num == 0)
					{
						break;
					}
				}
			}
			Plugin.Log.LogInfo((object)("Loaded font '" + text + "' for chat messages."));
			return new Font(text);
		}

		public override void ConstructPanelContent()
		{
			//IL_008f: 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_00b8: 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_0133: 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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			Font val = CreateFont();
			_chatBoxFont = TMP_FontAsset.CreateFontAsset(val, 90, 9, (GlyphRenderMode)4165, 1024, 1024, (AtlasPopulationMode)1, true);
			_chatFont = TMP_FontAsset.CreateFontAsset(val, 90, 9, (GlyphRenderMode)4165, 1024, 1024, (AtlasPopulationMode)1, true);
			ShaderUtilities.GetShaderPropertyIDs();
			((TMP_Asset)_chatFont).material.EnableKeyword(ShaderUtilities.Keyword_Outline);
			((TMP_Asset)_chatFont).material.SetFloat(ShaderUtilities.ID_FaceDilate, 0.3f);
			_container = UIHelper.CreateUIObject("container", base.PanelRoot);
			RectTransform component = _container.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0.5f);
			component.anchorMax = new Vector2(0.35f, 0.8f);
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(_container, (bool?)true, (bool?)false, (bool?)true, (bool?)true, (int?)0, (int?)10, (int?)10, (int?)10, (int?)10, (TextAnchor?)(TextAnchor)6);
			GameObject val2 = UIHelper.CreateUIObject("chat_box_container", base.PanelRoot);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.4f, 0.4f);
			component2.anchorMax = new Vector2(0.6f, 0.5f);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val2, (bool?)true, (bool?)false, (bool?)true, (bool?)true, (int?)0, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)4);
			TMP_FontAsset chatBoxFont = _chatBoxFont;
			_chatBox = UIHelper.CreateInputField(val2, "chat_box", null, "", null, 32, chatBoxFont);
			((Component)_chatBox).gameObject.AddComponent<Mask>();
			((Graphic)_chatBox.textComponent).color = InputColor;
			_chatBox.textComponent.alignment = (TextAlignmentOptions)513;
			_chatBox.characterLimit = 0;
			_chatBox.lineLimit = 1;
			((UnityEvent<string>)(object)_chatBox.onSubmit).AddListener((UnityAction<string>)OnSendMessage);
			_chatBoxContainer = ((Component)((Component)_chatBox).transform.parent).gameObject;
			Image val3 = _chatBoxContainer.AddComponent<Image>();
			val3.type = (Type)1;
			((Graphic)val3).color = BackgroundColor;
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(_chatBoxContainer, (bool?)true, (bool?)false, (bool?)true, (bool?)false, (int?)0, (int?)3, (int?)3, (int?)3, (int?)3, (TextAnchor?)(TextAnchor)4);
			RectTransform component3 = _chatBoxContainer.GetComponent<RectTransform>();
			LayoutRebuilder.ForceRebuildLayoutImmediate(component3);
			_chatBoxContainer.SetActive(false);
			Plugin.Instance.Network.AddChatMessageHandler(0, OnMessageReceived);
		}

		public void Update()
		{
			if (!Plugin.Instance.Network.Online)
			{
				foreach (Message line in _lines)
				{
					Object.Destroy((Object)(object)line.Line);
				}
				_lines.Clear();
				return;
			}
			foreach (Message line2 in _lines)
			{
				if (line2.Faded && _chatBoxContainer.activeSelf)
				{
					line2.Time = Time.unscaledTime;
					((Graphic)line2.Text).CrossFadeAlpha(1f, 0f, true);
					line2.Faded = false;
				}
				else if (!line2.Faded && line2.Time + 3f < Time.unscaledTime)
				{
					((Graphic)line2.Text).CrossFadeAlpha(0f, 0.5f, true);
					line2.Faded = true;
				}
			}
			if (!_chatBoxContainer.activeSelf)
			{
				if (_justClosed)
				{
					_justClosed = Input.GetKeyDown((KeyCode)13);
				}
				else if (Input.GetKeyDown((KeyCode)13))
				{
					_chatBoxContainer.SetActive(true);
					LocalGamestate.Instance.SetPlayerFreezeState(true);
				}
			}
			else if (!_chatBox.isFocused)
			{
				((Selectable)_chatBox).Select();
				_chatBox.ActivateInputField();
			}
		}

		private void OnSendMessage(string text)
		{
			if (!string.IsNullOrEmpty(text))
			{
				Plugin.Instance.Network.SendChatMessage(text);
			}
			_chatBox.text = "";
			_chatBoxContainer.SetActive(false);
			LocalGamestate.Instance.SetPlayerFreezeState(false);
			_justClosed = true;
		}

		private bool OnMessageReceived(string user, string message)
		{
			//IL_0070: 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)
			while (_lines.Count >= 8)
			{
				Message message2 = _lines[0];
				_lines.RemoveAt(0);
				Object.Destroy((Object)(object)message2.Line);
			}
			TextMeshProUGUI val = UIHelper.CreateText(_container, "message", user + ": " + message, _chatFont);
			((TMP_Text)val).alignment = (TextAlignmentOptions)513;
			((Graphic)val).color = ChatColor;
			((TMP_Text)val).fontSize = 20f;
			((TMP_Text)val).outlineColor = ChatBorderColor;
			((TMP_Text)val).outlineWidth = 0.3f;
			_lines.Add(new Message
			{
				Line = ((Component)val).gameObject,
				Text = (TMP_Text)(object)val,
				Time = Time.unscaledTime
			});
			return true;
		}
	}
	public class GameStatusPanel : BaseUI
	{
		private static readonly Color BackgroundColor = new Color(0.11f, 0.11f, 0.11f, 0.95f);

		private static readonly Color EntryColor = new Color(0.2f, 0.2f, 0.2f, 1f);

		private GameObject _playerList;

		public override string Name => "Game Status Panel";

		public override void ConstructPanelContent()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_00a4: 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_00db: 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_0102: 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_016d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UIHelper.CreateUIObject("container", base.PanelRoot);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0.5f);
			component.anchorMax = new Vector2(0.25f, 1f);
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(val, (bool?)true, (bool?)false, (bool?)true, (bool?)true, (int?)0, (int?)10, (int?)10, (int?)10, (int?)10, (TextAnchor?)(TextAnchor)0);
			_playerList = UIHelper.CreateUIObject("background", val);
			_playerList.AddComponent<Mask>();
			Image val2 = _playerList.AddComponent<Image>();
			val2.type = (Type)1;
			((Graphic)val2).color = BackgroundColor;
			RectTransform component2 = _playerList.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(_playerList, (bool?)true, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)10, (int?)10, (int?)10, (int?)10, (TextAnchor?)(TextAnchor)0);
			GameObject val3 = UIHelper.CreateUIObject("player_header", _playerList);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val3, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)0, (int?)0, (int?)0, (int?)15, (int?)15, (TextAnchor?)(TextAnchor)1);
			TextMeshProUGUI val4 = UIHelper.CreateText(val3, "name", "Name", UIManager.DefaultFont);
			((TMP_Text)val4).alignment = (TextAlignmentOptions)513;
			((Component)val4).gameObject.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			GameObject gameObject = ((Component)val4).gameObject;
			int? flexibleWidth = 1;
			UIHelper.SetLayoutElement(gameObject, null, null, flexibleWidth);
			TextMeshProUGUI val5 = UIHelper.CreateText(val3, "ping", "Ping", UIManager.DefaultFont);
			((TMP_Text)val5).alignment = (TextAlignmentOptions)514;
			((Component)val5).gameObject.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			UIHelper.SetLayoutElement(((Component)val5).gameObject, 40);
			LayoutRebuilder.ForceRebuildLayoutImmediate(_playerList.GetComponent<RectTransform>());
			foreach (PlayerManager.Player allPlayer in Plugin.Instance.PlayerManager.GetAllPlayers())
			{
				CreatePlayerLine(allPlayer);
			}
			Plugin.Instance.PlayerManager.OnPlayerAdded += CreatePlayerLine;
			LayoutRebuilder.ForceRebuildLayoutImmediate(_playerList.GetComponent<RectTransform>());
			_playerList.SetActive(false);
		}

		private void Update()
		{
			if (Plugin.Instance.Network.Online && Input.GetKeyDown((KeyCode)96))
			{
				_playerList.SetActive(!_playerList.activeSelf);
				Plugin.Log.LogInfo((object)$"List toggled {_playerList.activeSelf}");
			}
		}

		public void CreatePlayerLine(PlayerManager.Player player)
		{
			//IL_001c: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UIHelper.CreateBox(_playerList, $"player_{player.Id}", EntryColor);
			val.SetActive(false);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)5, (int?)5, (int?)15, (int?)15, (TextAnchor?)(TextAnchor)4);
			GameObject val2 = UIHelper.CreateUIObject("is_host", val);
			Image val3 = val2.AddComponent<Image>();
			val3.type = (Type)3;
			Texture2D crown = Plugin.Instance.TextureRepository.Crown;
			val3.sprite = Sprite.Create(crown, new Rect(0f, 0f, (float)((Texture)crown).width, (float)((Texture)crown).height), new Vector2(0.5f, 0.5f));
			UIHelper.SetLayoutElement(val2, 24);
			TextMeshProUGUI val4 = UIHelper.CreateText(val, "name", "", UIManager.DefaultFont);
			((TMP_Text)val4).alignment = (TextAlignmentOptions)513;
			((Component)val4).gameObject.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			GameObject gameObject = ((Component)val4).gameObject;
			int? flexibleWidth = 1;
			UIHelper.SetLayoutElement(gameObject, null, null, flexibleWidth);
			TextMeshProUGUI val5 = UIHelper.CreateText(val, "ping", "", UIManager.DefaultFont);
			((TMP_Text)val5).alignment = (TextAlignmentOptions)514;
			((Component)val5).gameObject.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			UIHelper.SetLayoutElement(((Component)val5).gameObject, 40);
			PlayerInfoControl playerInfoControl = val.AddComponent<PlayerInfoControl>();
			playerInfoControl.playerId = player.Id;
			playerInfoControl.hostIdentifier = val2;
			playerInfoControl.container = val;
			playerInfoControl.playerName = (TMP_Text)(object)val4;
			playerInfoControl.ping = (TMP_Text)(object)val5;
			val.SetActive(true);
			LayoutRebuilder.ForceRebuildLayoutImmediate(_playerList.GetComponent<RectTransform>());
		}
	}
	public class HostPanel : BaseUI
	{
		private struct LobbyCreationRequest
		{
			public string Name;

			public string Password;

			public int MaxPlayers;

			public bool CheatsEnabled;

			public ELobbyType Type;
		}

		private const int LabelWidth = 140;

		private readonly CallResult<LobbyCreated_t> _onLobbyCreatedCallResult;

		private LobbyCreationRequest? _currentRequest;

		private GameObject _window;

		public override string Name => "Host Panel";

		public ButtonControl Host { get; private set; }

		public HostPanel()
		{
			if (SteamManager.Initialized)
			{
				_onLobbyCreatedCallResult = CallResult<LobbyCreated_t>.Create((APIDispatchDelegate<LobbyCreated_t>)OnLobbyCreated);
			}
		}

		public override void ConstructPanelContent()
		{
			//IL_001b: 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_003d: 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_0073: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: 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_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: 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_02e1: 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_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_051c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_0535: 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)
			GameObject val = UIHelper.CreateUIObject("background", base.PanelRoot);
			Image val2 = val.AddComponent<Image>();
			val2.type = (Type)1;
			((Graphic)val2).color = UIManager.TransparentBackgroundColor;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			_window = UIHelper.CreateUIObject("panel", val);
			Image val3 = _window.AddComponent<Image>();
			val3.type = (Type)1;
			((Graphic)val3).color = UIManager.DarkBackgroundColor;
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(_window, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)0, (int?)5, (int?)5, (int?)5, (int?)5, (TextAnchor?)(TextAnchor)3);
			RectTransform component2 = _window.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.35f, 0.3f);
			component2.anchorMax = new Vector2(0.65f, 0.7f);
			GameObject val4 = UIHelper.CreateUIObject("panel", _window);
			Image val5 = val4.AddComponent<Image>();
			val5.type = (Type)1;
			((Graphic)val5).color = UIManager.BackgroundColor;
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(val4, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)20, (int?)80, (int?)60, (int?)60, (TextAnchor?)(TextAnchor)3);
			RectTransform component3 = val4.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(1f, 1f);
			string text = (SteamManager.Initialized ? SteamFriends.GetPersonaName() : "Unavailable");
			TMP_InputField nameField = UIHelper.CreateInputField(val4, "name", "Name", text + "'s Game", 140, 24);
			TMP_InputField passwordField = UIHelper.CreateInputField(val4, "password", "Password", "", 140, 24);
			passwordField.contentType = (ContentType)7;
			TMP_InputField maxPlayersField = UIHelper.CreateInputField(val4, "max_players", "Players", "8", 140, 2);
			maxPlayersField.contentType = (ContentType)3;
			ToggleControl friendsOnlyToggle = CreateToggle(val4, "friends_only", "Friends Only", value: false);
			ToggleControl enableCheatsToggle = CreateToggle(val4, "cheats_enabled", "Enable Cheats", value: false);
			GameObject val6 = UIHelper.CreateUIObject("buttons", val4);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val6, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)20, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)4);
			bool? ignoreLayout = true;
			UIHelper.SetLayoutElement(val6, null, null, null, null, null, null, ignoreLayout);
			RectTransform component4 = val6.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0f, 0.1f);
			component4.anchorMax = new Vector2(1f, 0.3f);
			Host = UIHelper.CreateButton(val6, "host", "Host");
			UIHelper.SetLayoutElement(((Component)Host).gameObject, 100);
			Host.OnClick += delegate
			{
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				Plugin.Log.LogInfo((object)("Creating " + (friendsOnlyToggle.Toggle.isOn ? "friends only" : "public") + " lobby"));
				CreateLobby(new LobbyCreationRequest
				{
					Name = nameField.text,
					MaxPlayers = int.Parse(maxPlayersField.text),
					Password = passwordField.text,
					CheatsEnabled = enableCheatsToggle.Toggle.isOn,
					Type = (ELobbyType)(friendsOnlyToggle.Toggle.isOn ? 1 : 2)
				});
				ThronefallAudioManager.Oneshot((AudioOneShot)11);
			};
			ButtonControl buttonControl = UIHelper.CreateButton(val6, "back", "Back");
			UIHelper.SetLayoutElement(((Component)buttonControl).gameObject, 100);
			buttonControl.OnClick += delegate
			{
				base.Enabled = false;
				((Selectable)UIManager.LobbyListPanel.Host.Button).Select();
				ThronefallAudioManager.Oneshot((AudioOneShot)11);
			};
			TMP_InputField obj = nameField;
			Navigation navigation = ((Selectable)nameField).navigation;
			((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)passwordField;
			((Navigation)(ref navigation)).selectOnUp = (Selectable)(object)Host.Button;
			((Selectable)obj).navigation = navigation;
			TMP_InputField obj2 = passwordField;
			navigation = ((Selectable)passwordField).navigation;
			((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)maxPlayersField;
			((Navigation)(ref navigation)).selectOnUp = (Selectable)(object)nameField;
			((Selectable)obj2).navigation = navigation;
			TMP_InputField obj3 = maxPlayersField;
			navigation = ((Selectable)maxPlayersField).navigation;
			((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)friendsOnlyToggle.Toggle;
			((Navigation)(ref navigation)).selectOnUp = (Selectable)(object)passwordField;
			((Selectable)obj3).navigation = navigation;
			friendsOnlyToggle.NavUp = (Selectable)(object)maxPlayersField;
			friendsOnlyToggle.NavDown = (Selectable)(object)Host.Button;
			Host.NavUp = (Selectable)(object)friendsOnlyToggle.Toggle;
			Host.NavDown = (Selectable)(object)nameField;
			Host.NavLeft = (Selectable)(object)buttonControl.Button;
			Host.NavRight = (Selectable)(object)buttonControl.Button;
			buttonControl.NavUp = (Selectable)(object)friendsOnlyToggle.Toggle;
			buttonControl.NavDown = (Selectable)(object)nameField;
			buttonControl.NavLeft = (Selectable)(object)Host.Button;
			buttonControl.NavRight = (Selectable)(object)Host.Button;
			LayoutRebuilder.ForceRebuildLayoutImmediate(_window.GetComponent<RectTransform>());
		}

		private static ToggleControl CreateToggle(GameObject panel, string name, string label, bool value)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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)
			GameObject val = UIHelper.CreateUIObject(name + "Group", panel);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val, (bool?)false, (bool?)false, (bool?)true, (bool?)false, (int?)20, (int?)5, (int?)5, (int?)5, (int?)5, (TextAnchor?)(TextAnchor)3);
			int? flexibleWidth = 1;
			UIHelper.SetLayoutElement(val, null, null, flexibleWidth);
			GameObject val2 = UIHelper.CreateBox(val, name + "_label_bg", Color.clear);
			GameObject gameObject = val2;
			bool? childControlWidth = true;
			TextAnchor? childAlignment = (TextAnchor)3;
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(gameObject, (bool?)null, (bool?)null, childControlWidth, (bool?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, childAlignment);
			GameObject gameObject2 = val2.gameObject;
			int? minWidth = 140;
			flexibleWidth = 0;
			UIHelper.SetLayoutElement(gameObject2, minWidth, null, flexibleWidth);
			val2.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			TextMeshProUGUI val3 = UIHelper.CreateText(val2, name + "_label", label + ": ");
			((TMP_Text)val3).alignment = (TextAlignmentOptions)513;
			val2 = UIHelper.CreateBox(val, name + "_bg", Color.clear);
			GameObject gameObject3 = val2;
			childControlWidth = true;
			childAlignment = (TextAnchor)4;
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(gameObject3, (bool?)null, (bool?)null, childControlWidth, (bool?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, childAlignment);
			GameObject gameObject4 = val2.gameObject;
			flexibleWidth = 1;
			UIHelper.SetLayoutElement(gameObject4, null, null, flexibleWidth);
			val2.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			ToggleControl toggleControl = UIHelper.CreateToggle(val2, name ?? "", value);
			GameObject gameObject5 = ((Component)toggleControl).gameObject;
			childAlignment = (TextAnchor)4;
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(gameObject5, (bool?)null, (bool?)null, (bool?)null, (bool?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, childAlignment);
			return toggleControl;
		}

		public void Update()
		{
			if (!UIManager.ExitHandled && Input.GetKeyDown((KeyCode)27))
			{
				base.Enabled = false;
				UIManager.ExitHandled = true;
				ThronefallAudioManager.Oneshot((AudioOneShot)11);
			}
		}

		private bool CreateLobby(LobbyCreationRequest request)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if (_currentRequest.HasValue)
			{
				return false;
			}
			_window.SetActive(false);
			_currentRequest = request;
			if (request.Password == string.Empty)
			{
				request.Password = null;
			}
			_onLobbyCreatedCallResult.Set(SteamMatchmaking.CreateLobby(request.Type, request.MaxPlayers), (APIDispatchDelegate<LobbyCreated_t>)null);
			return true;
		}

		private void OnLobbyCreated(LobbyCreated_t created, bool ioFailure)
		{
			//IL_0042: 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_0049: Invalid comparison between Unknown and I4
			//IL_0087: 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_005f: 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_00be: 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_00f1: 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_013f: Unknown result type (might be due to invalid IL or missing references)
			_window.SetActive(true);
			if (ioFailure)
			{
				UIManager.CreateMessageDialog("Error creating lobby", "Lobby creation failed with io error'");
				return;
			}
			if ((int)created.m_eResult != 1)
			{
				UIManager.CreateMessageDialog("Error creating lobby", $"Lobby creation failed with error '{created.m_eResult}'");
				return;
			}
			CSteamID id = new CSteamID(created.m_ulSteamIDLobby);
			string password = _currentRequest.Value.Password;
			string text = (string.IsNullOrEmpty(password) ? "no" : "yes");
			SteamMatchmaking.SetLobbyData(id, "name", _currentRequest.Value.Name);
			SteamMatchmaking.SetLobbyData(id, "password", text);
			SteamMatchmaking.SetLobbyData(id, "version", "thronefall_mp_1.2.2");
			SteamMatchmaking.SetLobbyData(id, "cheats_enabled", _currentRequest.Value.CheatsEnabled ? "yes" : "no");
			Plugin.Log.LogInfo((object)$"Lobby {created.m_ulSteamIDLobby} created with name '{_currentRequest.Value.Name}' password '{text}'");
			Plugin.CallbackOnLoad("_LevelSelect", waitForTransition: false, delegate
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				Plugin.Instance.Network.Host(id, _currentRequest.Value.Password);
				_currentRequest = null;
			});
			base.Enabled = false;
			UIManager.LobbyListPanel.Close();
			SceneTransitionManager.instance.TransitionFromNullToLevelSelect();
		}
	}
	public class LobbyListPanel : BaseUI
	{
		private Callback<LobbyDataUpdate_t> _lobbyUpdated;

		private readonly CallResult<LobbyMatchList_t> _onLobbyMatchListCallResult;

		private MessageDialog _activeConnectionDialog;

		private LobbyItem _currentlySelectedLobby;

		private GameObject _lobbyList;

		private ToggleControl _friendsOnly;

		private ToggleControl _showWithPassword;

		private ToggleControl _showFull;

		private ButtonControl _connect;

		private ButtonControl _back;

		private CustomScrollRect _scrollRect;

		private bool _muteSound;

		private List<LobbyItem> _lobbies = new List<LobbyItem>();

		private Dictionary<CSteamID, LobbyItem> _idToLobbies = new Dictionary<CSteamID, LobbyItem>();

		private const float UpdateCooldown = 2f;

		private float _timer;

		public override string Name => "Lobby List Panel";

		public ButtonControl Host { get; private set; }

		public LobbyListPanel()
		{
			if (SteamManager.Initialized)
			{
				_lobbyUpdated = new Callback<LobbyDataUpdate_t>((DispatchDelegate<LobbyDataUpdate_t>)OnLobbyDataUpdated, false);
				_onLobbyMatchListCallResult = CallResult<LobbyMatchList_t>.Create((APIDispatchDelegate<LobbyMatchList_t>)OnLobbiesRefreshed);
			}
		}

		private void PlaySelectSound()
		{
			if (!_muteSound)
			{
			}
			_muteSound = false;
		}

		private void RefreshLobbies()
		{
			//IL_014e: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			if (!SteamManager.Initialized)
			{
				return;
			}
			if (_friendsOnly.Toggle.isOn)
			{
				ClearLobbyEntries();
				Plugin.Log.LogInfo((object)"Refreshing list with friends games.");
				int friendCount = SteamFriends.GetFriendCount((EFriendFlags)4);
				FriendGameInfo_t val = default(FriendGameInfo_t);
				for (int i = 0; i < friendCount; i++)
				{
					CSteamID friendByIndex = SteamFriends.GetFriendByIndex(i, (EFriendFlags)4);
					if (SteamFriends.GetFriendGamePlayed(friendByIndex, ref val) && ((CSteamID)(ref val.m_steamIDLobby)).IsValid())
					{
						Plugin.Log.LogInfo((object)$"Game {val.m_steamIDLobby.m_SteamID}");
						SteamMatchmaking.RequestLobbyData(val.m_steamIDLobby);
					}
				}
				((ScrollRect)_scrollRect).verticalNormalizedPosition = 1f;
			}
			else
			{
				SteamMatchmaking.AddRequestLobbyListDistanceFilter((ELobbyDistanceFilter)3);
				if (!_showFull.Toggle.isOn)
				{
					Plugin.Log.LogInfo((object)"Adding empty slot filter");
					SteamMatchmaking.AddRequestLobbyListFilterSlotsAvailable(1);
				}
				if (!_showWithPassword.Toggle.isOn)
				{
					Plugin.Log.LogInfo((object)"Adding no password filter");
					SteamMatchmaking.AddRequestLobbyListStringFilter("password", "yes", (ELobbyComparison)3);
				}
				_onLobbyMatchListCallResult.Set(SteamMatchmaking.RequestLobbyList(), (APIDispatchDelegate<LobbyMatchList_t>)null);
			}
		}

		private void SelectLobby(LobbyItem item)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_00c6: 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)
			if ((Object)(object)_currentlySelectedLobby != (Object)null)
			{
				Image component = _currentlySelectedLobby.LobbyGameObject.GetComponent<Image>();
				((Graphic)component).color = UIManager.TransparentBackgroundColor;
			}
			_currentlySelectedLobby = item;
			Image component2 = _currentlySelectedLobby.LobbyGameObject.GetComponent<Image>();
			((Graphic)component2).color = UIManager.SelectedTransparentBackgroundColor;
			_connect.SetInteractable(value: true);
			Button button = Host.Button;
			Navigation navigation = ((Selectable)Host.Button).navigation;
			((Navigation)(ref navigation)).selectOnLeft = (Selectable)(object)_connect.Button;
			((Selectable)button).navigation = navigation;
			Button button2 = _back.Button;
			navigation = ((Selectable)_back.Button).navigation;
			((Navigation)(ref navigation)).selectOnRight = (Selectable)(object)_connect.Button;
			((Selectable)button2).navigation = navigation;
		}

		private void ClearLobbyEntries()
		{
			foreach (LobbyItem lobby in _lobbies)
			{
				Object.Destroy((Object)(object)((Component)lobby).gameObject);
			}
			_lobbies.Clear();
			_idToLobbies.Clear();
			_currentlySelectedLobby = null;
			_connect.SetInteractable(value: false);
			Host.NavLeft = (Selectable)(object)_back.Button;
			_back.NavRight = (Selectable)(object)Host.Button;
		}

		public void Open()
		{
			base.Enabled = true;
			RefreshLobbies();
			((Selectable)Host.Button).Select();
		}

		public void Close()
		{
			base.Enabled = false;
		}

		private void Back()
		{
			Close();
			UIManager.TitleScreen.SetActive(true);
			ThronefallAudioManager.Oneshot((AudioOneShot)11);
		}

		public void Update()
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (!UIManager.HostPanel.Enabled && !UIManager.ExitHandled && Input.GetKeyDown((KeyCode)27))
			{
				UIManager.ExitHandled = true;
				Back();
			}
			_timer += Time.deltaTime;
			if (_timer < 2f)
			{
				return;
			}
			_timer = 0f;
			foreach (LobbyItem lobby in _lobbies)
			{
				SteamMatchmaking.RequestLobbyData(lobby.LobbyInfo.Id);
			}
		}

		private void OnLobbiesRefreshed(LobbyMatchList_t list, bool ioFailure)
		{
			//IL_0041: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: 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_0067: 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_009f: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: 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_00f9: Unknown result type (might be due to invalid IL or missing references)
			ClearLobbyEntries();
			if (!base.Enabled)
			{
				return;
			}
			if (ioFailure)
			{
				ESteamAPICallFailure aPICallFailureReason = SteamUtils.GetAPICallFailureReason(_onLobbyMatchListCallResult.Handle);
				return;
			}
			Plugin.Log.LogInfo((object)$"Populating Lobby list {list.m_nLobbiesMatching}");
			for (int i = 0; i < list.m_nLobbiesMatching; i++)
			{
				CSteamID lobbyByIndex = SteamMatchmaking.GetLobbyByIndex(i);
				if (!(SteamMatchmaking.GetLobbyData(lobbyByIndex, "version") != "thronefall_mp_1.2.2"))
				{
					Plugin.Log.LogInfo((object)string.Format("Lobby {0} password {1}", lobbyByIndex.m_SteamID, SteamMatchmaking.GetLobbyData(lobbyByIndex, "password")));
					AddLobbyEntry(new Lobby
					{
						Id = lobbyByIndex,
						Name = SteamMatchmaking.GetLobbyData(lobbyByIndex, "name"),
						PlayerCount = SteamMatchmaking.GetNumLobbyMembers(lobbyByIndex),
						MaxPlayerCount = SteamMatchmaking.GetLobbyMemberLimit(lobbyByIndex),
						HasPassword = (SteamMatchmaking.GetLobbyData(lobbyByIndex, "password") == "yes")
					});
				}
			}
			((ScrollRect)_scrollRect).verticalNormalizedPosition = 0f;
		}

		private void OnLobbyDataUpdated(LobbyDataUpdate_t data)
		{
			//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_002f: 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_0057: 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_006c: 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_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_00bf: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			if (!base.Enabled || data.m_ulSteamIDLobby != data.m_ulSteamIDMember || data.m_bSuccess == 0)
			{
				return;
			}
			CSteamID val = default(CSteamID);
			((CSteamID)(ref val))..ctor(data.m_ulSteamIDLobby);
			if (!_idToLobbies.TryGetValue(val, out var value))
			{
				if (!(SteamMatchmaking.GetLobbyData(val, "version") != "thronefall_mp_1.2.2"))
				{
					AddLobbyEntry(new Lobby
					{
						Id = val,
						Name = SteamMatchmaking.GetLobbyData(val, "name"),
						PlayerCount = SteamMatchmaking.GetNumLobbyMembers(val),
						MaxPlayerCount = SteamMatchmaking.GetLobbyMemberLimit(val),
						HasPassword = (SteamMatchmaking.GetLobbyData(val, "password") == "yes")
					});
				}
			}
			else if (data.m_bSuccess == 0)
			{
				if ((Object)(object)value == (Object)(object)_currentlySelectedLobby)
				{
					_currentlySelectedLobby = null;
					_connect.SetInteractable(value: false);
					Host.NavLeft = (Selectable)(object)_back.Button;
					_back.NavRight = (Selectable)(object)Host.Button;
				}
				Object.Destroy((Object)(object)((Component)value).gameObject);
				_lobbies.Remove(value);
				_idToLobbies.Remove(value.LobbyInfo.Id);
			}
			else
			{
				value.LobbyInfo.PlayerCount = SteamMatchmaking.GetNumLobbyMembers(value.LobbyInfo.Id);
				value.LobbyInfo.MaxPlayerCount = SteamMatchmaking.GetLobbyMemberLimit(value.LobbyInfo.Id);
				((TMP_Text)value.PlayerCount).text = $"{value.LobbyInfo.PlayerCount}/{value.LobbyInfo.MaxPlayerCount}";
			}
		}

		public override void ConstructPanelContent()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_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_0145: 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_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: 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_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0574: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0597: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0929: Unknown result type (might be due to invalid IL or missing references)
			//IL_092f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = UIHelper.CreateUIObject("multiplayer", base.PanelRoot);
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(val, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)20, (int?)80, (int?)80, (int?)120, (int?)120, (TextAnchor?)(TextAnchor)4);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			GameObject val2 = UIHelper.CreateUIObject("lobbies", val);
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(val2, (bool?)true, (bool?)false, (bool?)true, (bool?)true, (int?)2, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)1);
			int? flexibleHeight = 1;
			UIHelper.SetLayoutElement(val2, null, null, null, flexibleHeight);
			GameObject val3 = UIHelper.CreateUIObject("header", val2);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val3, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)0, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)4);
			flexibleHeight = 40;
			int? flexibleHeight2 = 0;
			UIHelper.SetLayoutElement(val3, null, flexibleHeight, null, flexibleHeight2);
			TextMeshProUGUI val4 = UIHelper.CreateText(val3, "name", "Name");
			((TMP_Text)val4).alignment = (TextAlignmentOptions)2049;
			GameObject gameObject = ((Component)val4).gameObject;
			flexibleHeight2 = 9999999;
			UIHelper.SetLayoutElement(gameObject, null, null, flexibleHeight2);
			val4 = UIHelper.CreateText(val3, "player_count", "Player Count");
			((TMP_Text)val4).alignment = (TextAlignmentOptions)2050;
			UIHelper.SetLayoutElement(((Component)val4).gameObject, 160);
			val4 = UIHelper.CreateText(val3, "password", "");
			((TMP_Text)val4).alignment = (TextAlignmentOptions)2050;
			UIHelper.SetLayoutElement(((Component)val4).gameObject, 50);
			GameObject val5 = UIHelper.CreateUIObject("separator", val2);
			Image val6 = val5.AddComponent<Image>();
			val6.type = (Type)1;
			((Graphic)val6).color = UIManager.TextColor;
			GameObject gameObject2 = val5;
			flexibleHeight2 = 2;
			flexibleHeight = 0;
			UIHelper.SetLayoutElement(gameObject2, null, flexibleHeight2, null, flexibleHeight);
			GameObject val7 = UIHelper.CreateUIObject("scroller", val2);
			val7.gameObject.AddComponent<RectMask2D>();
			_lobbyList = UIHelper.CreateUIObject("lobby_list", val7);
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(_lobbyList, (bool?)true, (bool?)false, (bool?)true, (bool?)true, (int?)4, (int?)10, (int?)10, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)1);
			component = _lobbyList.GetComponent<RectTransform>();
			component.pivot = new Vector2(0.5f, 1f);
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			ContentSizeFitter val8 = _lobbyList.AddComponent<ContentSizeFitter>();
			val8.verticalFit = (FitMode)2;
			_scrollRect = val7.gameObject.AddComponent<CustomScrollRect>();
			((ScrollRect)_scrollRect).movementType = (MovementType)2;
			((ScrollRect)_scrollRect).inertia = false;
			((ScrollRect)_scrollRect).horizontal = false;
			((ScrollRect)_scrollRect).vertical = true;
			((ScrollRect)_scrollRect).scrollSensitivity = 50f;
			((ScrollRect)_scrollRect).content = _lobbyList.GetComponent<RectTransform>();
			flexibleHeight = 1;
			UIHelper.SetLayoutElement(val7, null, null, null, flexibleHeight);
			val5 = UIHelper.CreateUIObject("separator", val2);
			val6 = val5.AddComponent<Image>();
			val6.type = (Type)1;
			((Graphic)val6).color = UIManager.TextColor;
			GameObject gameObject3 = val5;
			flexibleHeight = 2;
			flexibleHeight2 = 0;
			UIHelper.SetLayoutElement(gameObject3, null, flexibleHeight, null, flexibleHeight2);
			GameObject val9 = UIHelper.CreateUIObject("filters", val);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val9, (bool?)false, (bool?)true, (bool?)true, (bool?)true, (int?)0, (int?)0, (int?)0, (int?)20, (int?)20, (TextAnchor?)(TextAnchor)3);
			flexibleHeight2 = 40;
			flexibleHeight = 0;
			UIHelper.SetLayoutElement(val9, null, flexibleHeight2, null, flexibleHeight);
			ButtonControl buttonControl = UIHelper.CreateButton(val9, "refresh", "Refresh");
			buttonControl.Normal.Size = 24f;
			buttonControl.Hover.Size = 28f;
			buttonControl.NormalSelected.Size = 28f;
			buttonControl.HoverSelected.Size = 28f;
			buttonControl.Noninteractive.Size = 24f;
			buttonControl.Reset();
			buttonControl.OnClick += delegate
			{
				RefreshLobbies();
				ThronefallAudioManager.Oneshot((AudioOneShot)11);
			};
			GameObject gameObject4 = ((Component)buttonControl).gameObject;
			int? minWidth = 120;
			flexibleHeight = 160;
			UIHelper.SetLayoutElement(gameObject4, minWidth, null, null, null, flexibleHeight);
			_friendsOnly = UIHelper.CreateLeftToggle(val9, "friends_only", "Friends Only");
			GameObject gameObject5 = ((Component)_friendsOnly).gameObject;
			flexibleHeight = 5;
			flexibleHeight2 = 20;
			int? padBottom = 5;
			int? padRight = 20;
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(gameObject5, (bool?)null, (bool?)null, (bool?)null, (bool?)null, (int?)null, flexibleHeight, padBottom, flexibleHeight2, padRight, (TextAnchor?)null);
			_showWithPassword = UIHelper.CreateLeftToggle(val9, "show_with_password", "Show with Password", startsOn: true);
			GameObject gameObject6 = ((Component)_showWithPassword).gameObject;
			padRight = 5;
			padBottom = 20;
			flexibleHeight2 = 5;
			flexibleHeight = 20;
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(gameObject6, (bool?)null, (bool?)null, (bool?)null, (bool?)null, (int?)null, padRight, flexibleHeight2, padBottom, flexibleHeight, (TextAnchor?)null);
			_showFull = UIHelper.CreateLeftToggle(val9, "show_full", "Show Full", startsOn: true);
			GameObject gameObject7 = ((Component)_showFull).gameObject;
			flexibleHeight = 5;
			flexibleHeight2 = 20;
			padBottom = 5;
			padRight = 20;
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(gameObject7, (bool?)null, (bool?)null, (bool?)null, (bool?)null, (int?)null, flexibleHeight, padBottom, flexibleHeight2, padRight, (TextAnchor?)null);
			GameObject val10 = UIHelper.CreateUIObject("buttons", val);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val10, (bool?)false, (bool?)true, (bool?)true, (bool?)true, (int?)0, (int?)0, (int?)0, (int?)20, (int?)20, (TextAnchor?)(TextAnchor)4);
			padRight = 80;
			padBottom = 0;
			UIHelper.SetLayoutElement(val10, null, padRight, null, padBottom);
			_connect = UIHelper.CreateButton(val10, "connect", "Connect");
			_connect.OnClick += delegate
			{
				if (_currentlySelectedLobby.LobbyInfo.HasPassword)
				{
					UIManager.CreatePasswordDialog(ConnectToLobby, delegate
					{
					});
				}
				else
				{
					ConnectToLobby(null);
				}
			};
			_connect.OnExit += delegate
			{
				_muteSound = false;
			};
			_connect.OnSelected += PlaySelectSound;
			GameObject gameObject8 = ((Component)_connect).gameObject;
			int? minWidth2 = 160;
			padBottom = 300;
			UIHelper.SetLayoutElement(gameObject8, minWidth2, null, null, null, padBottom);
			_connect.SetInteractable(value: false);
			Host = UIHelper.CreateButton(val10, "host", "Host");
			Host.OnClick += delegate
			{
				UIManager.HostPanel.Enabled = true;
				((Selectable)UIManager.HostPanel.Host.Button).Select();
				ThronefallAudioManager.Oneshot((AudioOneShot)11);
			};
			Host.OnExit += delegate
			{
				_muteSound = false;
			};
			Host.OnSelected += PlaySelectSound;
			GameObject gameObject9 = ((Component)Host).gameObject;
			int? minWidth3 = 100;
			padBottom = 300;
			UIHelper.SetLayoutElement(gameObject9, minWidth3, null, null, null, padBottom);
			_back = UIHelper.CreateButton(val10, "back", "Back");
			_back.OnClick += Back;
			_back.OnExit += delegate
			{
				_muteSound = false;
			};
			_back.OnSelected += PlaySelectSound;
			GameObject gameObject10 = ((Component)_back).gameObject;
			int? minWidth4 = 100;
			padBottom = 300;
			UIHelper.SetLayoutElement(gameObject10, minWidth4, null, null, null, padBottom);
			_connect.NavLeft = (Selectable)(object)_back.Button;
			_connect.NavRight = (Selectable)(object)Host.Button;
			Host.NavLeft = (Selectable)(object)_back.Button;
			Host.NavRight = (Selectable)(object)_back.Button;
			_back.NavLeft = (Selectable)(object)Host.Button;
			_back.NavRight = (Selectable)(object)Host.Button;
		}

		private void ConnectToLobby(string password)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Instance.Network.ConnectLobby(_currentlySelectedLobby.LobbyInfo.Id, password);
			_activeConnectionDialog = UIManager.CreateMessageDialog("Connecting", "Connecting to " + _currentlySelectedLobby.LobbyInfo.Name + " please wait...", "Cancel", null, delegate
			{
				_activeConnectionDialog = null;
				Plugin.Instance.Network.Local();
			});
			ThronefallAudioManager.Oneshot((AudioOneShot)11);
		}

		public void ShowHideConnectingDialog(bool show)
		{
			if (!((Object)(object)_activeConnectionDialog == (Object)null))
			{
				((Component)_activeConnectionDialog).gameObject.SetActive(show);
			}
		}

		public void CloseConnectingDialog()
		{
			if (!((Object)(object)_activeConnectionDialog == (Object)null))
			{
				Object.Destroy((Object)(object)((Component)_activeConnectionDialog).gameObject);
				_activeConnectionDialog = null;
			}
		}

		private void AddLobbyEntry(Lobby info)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: 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_0297: 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)
			GameObject val = UIHelper.CreateBox(_lobbyList, info.Name, UIManager.TransparentBackgroundColor);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val, (bool?)false, (bool?)true, (bool?)true, (bool?)true, (int?)0, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)4);
			ContentSizeFitter val2 = val.AddComponent<ContentSizeFitter>();
			val2.verticalFit = (FitMode)2;
			TextMeshProUGUI val3 = UIHelper.CreateText(val, "name", info.Name);
			((TMP_Text)val3).alignment = (TextAlignmentOptions)513;
			GameObject gameObject = ((Component)val3).gameObject;
			int? flexibleWidth = 9999999;
			UIHelper.SetLayoutElement(gameObject, null, null, flexibleWidth);
			val3 = UIHelper.CreateText(val, "player_count", $"{info.PlayerCount}/{info.MaxPlayerCount}");
			((TMP_Text)val3).alignment = (TextAlignmentOptions)514;
			UIHelper.SetLayoutElement(((Component)val3).gameObject, 160);
			GameObject val4 = UIHelper.CreateUIObject("password", val);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val4, (bool?)false, (bool?)true, (bool?)true, (bool?)true, (int?)0, (int?)2, (int?)2, (int?)4, (int?)4, (TextAnchor?)(TextAnchor)4);
			UIHelper.SetLayoutElement(val4, 50);
			if (info.HasPassword)
			{
				GameObject val5 = UIHelper.CreateUIObject("image", val4);
				Image val6 = val5.gameObject.AddComponent<Image>();
				val6.type = (Type)3;
				Texture2D val7 = Plugin.Instance.TextureRepository.Lock;
				val6.sprite = Sprite.Create(val7, new Rect(0f, 0f, (float)((Texture)val7).width, (float)((Texture)val7).height), new Vector2(0.5f, 0.5f));
			}
			LobbyItem lobbyItem = val.AddComponent<LobbyItem>();
			lobbyItem.LobbyGameObject = val;
			lobbyItem.LobbyInfo = info;
			lobbyItem.PlayerCount = val3;
			lobbyItem.OnClick += delegate
			{
				SelectLobby(lobbyItem);
			};
			_lobbies.Add(lobbyItem);
			if (!_idToLobbies.ContainsKey(info.Id))
			{
				_idToLobbies.Add(info.Id, lobbyItem);
			}
		}
	}
}
namespace ThronefallMP.UI.Dialogs
{
	public class MessageDialog : BaseUI
	{
		public delegate void ClickDelegate();

		public ClickDelegate OnClick;

		private TextMeshProUGUI _title;

		private TextMeshProUGUI _message;

		private GameObject _background;

		private ButtonControl _button;

		public override string Name => "Message Dialog";

		public bool FadeScreen
		{
			get
			{
				return _background.activeSelf;
			}
			set
			{
				_background.SetActive(value);
			}
		}

		public string Title
		{
			get
			{
				return ((TMP_Text)_title).text;
			}
			set
			{
				((TMP_Text)_title).text = value;
			}
		}

		public string Message
		{
			get
			{
				return ((TMP_Text)_message).text;
			}
			set
			{
				((TMP_Text)_message).text = value;
			}
		}

		public string ButtonText
		{
			get
			{
				return ((TMP_Text)_button.Text).text;
			}
			set
			{
				((TMP_Text)_button.Text).text = value;
			}
		}

		public Color Color
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return ((Graphic)_message).color;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				((Graphic)_message).color = value;
			}
		}

		public override void ConstructPanelContent()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_008e: 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_00b0: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: 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_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			_background = UIHelper.CreateUIObject("background", base.PanelRoot);
			Image val = _background.AddComponent<Image>();
			val.type = (Type)1;
			((Graphic)val).color = UIManager.TransparentBackgroundColor;
			RectTransform component = _background.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			GameObject val2 = UIHelper.CreateUIObject("panel", base.PanelRoot);
			Image val3 = val2.AddComponent<Image>();
			val3.type = (Type)1;
			((Graphic)val3).color = UIManager.DarkBackgroundColor;
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(val2, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)0, (int?)5, (int?)5, (int?)5, (int?)5, (TextAnchor?)(TextAnchor)3);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.35f, 0.3f);
			component2.anchorMax = new Vector2(0.65f, 0.7f);
			GameObject val4 = UIHelper.CreateUIObject("panel", val2);
			Image val5 = val4.AddComponent<Image>();
			val5.type = (Type)1;
			((Graphic)val5).color = UIManager.BackgroundColor;
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(val4, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)20, (int?)20, (int?)60, (int?)60, (TextAnchor?)(TextAnchor)4);
			RectTransform component3 = val4.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(1f, 1f);
			GameObject val6 = UIHelper.CreateUIObject("titleContainer", val4);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val6, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)20, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)4);
			bool? ignoreLayout = true;
			UIHelper.SetLayoutElement(val6, null, null, null, null, null, null, ignoreLayout);
			RectTransform component4 = val6.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0f, 0.7f);
			component4.anchorMax = new Vector2(1f, 0.9f);
			_title = UIHelper.CreateText(val6, "title", "Title");
			((TMP_Text)_title).fontSize = 36f;
			((TMP_Text)_title).alignment = (TextAlignmentOptions)514;
			_message = UIHelper.CreateText(val4, "message", "Message");
			((TMP_Text)_message).alignment = (TextAlignmentOptions)514;
			GameObject val7 = UIHelper.CreateUIObject("buttons", val4);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val7, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)20, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)4);
			ignoreLayout = true;
			UIHelper.SetLayoutElement(val7, null, null, null, null, null, null, ignoreLayout);
			RectTransform component5 = val7.GetComponent<RectTransform>();
			component5.anchorMin = new Vector2(0f, 0.1f);
			component5.anchorMax = new Vector2(1f, 0.3f);
			_button = UIHelper.CreateButton(val7, "button", "Close");
			UIHelper.SetLayoutElement(((Component)_button).gameObject, 100);
			_button.OnClick += delegate
			{
				OnClick?.Invoke();
				Object.Destroy((Object)(object)((Component)this).gameObject);
			};
			LayoutRebuilder.ForceRebuildLayoutImmediate(val2.GetComponent<RectTransform>());
		}

		public void OnEnable()
		{
			UIFramePatch.DisableGameUIInputCount++;
			if ((Object)(object)_button != (Object)null)
			{
				((Selectable)_button.Button).Select();
			}
		}

		public void OnDisable()
		{
			UIFramePatch.DisableGameUIInputCount--;
		}
	}
	public class PasswordDialog : BaseUI
	{
		public delegate void Confirm(string password);

		public delegate void Cancel();

		public Confirm OnConfirm;

		public Cancel OnCancel;

		private GameObject _background;

		private TMP_InputField _input;

		public override string Name => "Password Dialog";

		public bool FadeScreen
		{
			get
			{
				return _background.activeSelf;
			}
			set
			{
				_background.SetActive(value);
			}
		}

		public override void ConstructPanelContent()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_008e: 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_00b0: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: 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_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			_background = UIHelper.CreateUIObject("background", base.PanelRoot);
			Image val = _background.AddComponent<Image>();
			val.type = (Type)1;
			((Graphic)val).color = UIManager.TransparentBackgroundColor;
			RectTransform component = _background.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			GameObject val2 = UIHelper.CreateUIObject("panel", base.PanelRoot);
			Image val3 = val2.AddComponent<Image>();
			val3.type = (Type)1;
			((Graphic)val3).color = UIManager.DarkBackgroundColor;
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(val2, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)0, (int?)5, (int?)5, (int?)5, (int?)5, (TextAnchor?)(TextAnchor)3);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.35f, 0.4f);
			component2.anchorMax = new Vector2(0.65f, 0.6f);
			GameObject val4 = UIHelper.CreateUIObject("panel", val2);
			Image val5 = val4.AddComponent<Image>();
			val5.type = (Type)1;
			((Graphic)val5).color = UIManager.BackgroundColor;
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(val4, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)20, (int?)20, (int?)60, (int?)60, (TextAnchor?)(TextAnchor)4);
			RectTransform component3 = val4.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(1f, 1f);
			GameObject val6 = UIHelper.CreateUIObject("titleContainer", val4);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val6, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)20, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)4);
			bool? ignoreLayout = true;
			UIHelper.SetLayoutElement(val6, null, null, null, null, null, null, ignoreLayout);
			RectTransform component4 = val6.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0f, 0.7f);
			component4.anchorMax = new Vector2(1f, 0.9f);
			TextMeshProUGUI val7 = UIHelper.CreateText(val6, "title", "Password");
			((TMP_Text)val7).fontSize = 36f;
			((TMP_Text)val7).alignment = (TextAlignmentOptions)514;
			_input = UIHelper.CreateInputField(val4, "password", null, "", 24);
			GameObject val8 = UIHelper.CreateUIObject("buttons", val4);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val8, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)20, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)4);
			ignoreLayout = true;
			UIHelper.SetLayoutElement(val8, null, null, null, null, null, null, ignoreLayout);
			RectTransform component5 = val8.GetComponent<RectTransform>();
			component5.anchorMin = new Vector2(0f, 0.1f);
			component5.anchorMax = new Vector2(1f, 0.3f);
			ButtonControl buttonControl = UIHelper.CreateButton(val8, "connect", "Connect");
			UIHelper.SetLayoutElement(((Component)buttonControl).gameObject, 120);
			buttonControl.OnClick += delegate
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				OnConfirm?.Invoke(_input.text);
			};
			ButtonControl buttonControl2 = UIHelper.CreateButton(val8, "cancel", "Cancel");
			UIHelper.SetLayoutElement(((Component)buttonControl2).gameObject, 120);
			buttonControl2.OnClick += delegate
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				OnCancel?.Invoke();
			};
			LayoutRebuilder.ForceRebuildLayoutImmediate(val2.GetComponent<RectTransform>());
		}

		public void OnEnable()
		{
			UIFramePatch.DisableGameUIInputCount++;
			if ((Object)(object)_input != (Object)null)
			{
				_input.text = "";
			}
		}

		public void OnDisable()
		{
			UIFramePatch.DisableGameUIInputCount--;
		}
	}
	public class WeaponDialog : BaseUI
	{
		private delegate void WeaponChanged();

		private TextMeshProUGUI _title;

		private GameObject _background;

		private ButtonControl _button;

		private Equipment _selectedEquipment;

		public override string Name => "Weapon Dialog";

		public string ButtonText
		{
			get
			{
				return ((TMP_Text)_button.Text).text;
			}
			set
			{
				((TMP_Text)_button.Text).text = value;
			}
		}

		private event WeaponChanged OnWeaponChanged;

		public override void ConstructPanelContent()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_008e: 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_00b0: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: 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_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0545: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_0587: Unknown result type (might be due to invalid IL or missing references)
			//IL_0593: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c9: Unknown result type (might be due to invalid IL or missing references)
			_background = UIHelper.CreateUIObject("background", base.PanelRoot);
			Image val = _background.AddComponent<Image>();
			val.type = (Type)1;
			((Graphic)val).color = UIManager.TransparentBackgroundColor;
			RectTransform component = _background.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			GameObject val2 = UIHelper.CreateUIObject("panel", base.PanelRoot);
			Image val3 = val2.AddComponent<Image>();
			val3.type = (Type)1;
			((Graphic)val3).color = UIManager.DarkBackgroundColor;
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(val2, (bool?)true, (bool?)true, (bool?)true, (bool?)true, (int?)0, (int?)5, (int?)5, (int?)5, (int?)5, (TextAnchor?)(TextAnchor)3);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.35f, 0.35f);
			component2.anchorMax = new Vector2(0.65f, 0.6f);
			GameObject val4 = UIHelper.CreateUIObject("panel", val2);
			Image val5 = val4.AddComponent<Image>();
			val5.type = (Type)1;
			((Graphic)val5).color = UIManager.BackgroundColor;
			UIHelper.SetLayoutGroup<VerticalLayoutGroup>(val4, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)5, (int?)20, (int?)20, (int?)60, (int?)60, (TextAnchor?)(TextAnchor)4);
			RectTransform component3 = val4.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(1f, 1f);
			GameObject val6 = UIHelper.CreateUIObject("titleContainer", val4);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val6, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)20, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)4);
			bool? ignoreLayout = true;
			UIHelper.SetLayoutElement(val6, null, null, null, null, null, null, ignoreLayout);
			RectTransform component4 = val6.GetComponent<RectTransform>();
			component4.anchorMin = new Vector2(0f, 0.7f);
			component4.anchorMax = new Vector2(1f, 0.9f);
			_title = UIHelper.CreateText(val6, "title", "Weapon Selection");
			((TMP_Text)_title).fontSize = 36f;
			((TMP_Text)_title).alignment = (TextAlignmentOptions)514;
			GameObject val7 = UIHelper.CreateUIObject("weapons", val4);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val7, (bool?)false, (bool?)false, (bool?)false, (bool?)false, (int?)20, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)4);
			Selectable component5 = AddWeaponIcon(val7, Equipment.LongBow).GetComponent<Selectable>();
			Selectable component6 = AddWeaponIcon(val7, Equipment.LightSpear).GetComponent<Selectable>();
			Selectable component7 = AddWeaponIcon(val7, Equipment.HeavySword).GetComponent<Selectable>();
			_selectedEquipment = Equipment.LongBow;
			this.OnWeaponChanged?.Invoke();
			GameObject val8 = UIHelper.CreateUIObject("buttons", val4);
			UIHelper.SetLayoutGroup<HorizontalLayoutGroup>(val8, (bool?)false, (bool?)false, (bool?)true, (bool?)true, (int?)20, (int?)0, (int?)0, (int?)0, (int?)0, (TextAnchor?)(TextAnchor)4);
			ignoreLayout = true;
			UIHelper.SetLayoutElement(val8, null, null, null, null, null, null, ignoreLayout);
			RectTransform component8 = val8.GetComponent<RectTransform>();
			component8.anchorMin = new Vector2(0f, 0.1f);
			component8.anchorMax = new Vector2(1f, 0.3f);
			_button = UIHelper.CreateButton(val8, "button", "Confirm");
			UIHelper.SetLayoutElement(((Component)_button).gameObject, 140);
			_button.OnClick += delegate
			{
				//IL_0065: 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_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				WeaponResponsePacket weaponResponsePacket = new WeaponResponsePacket
				{
					Weapon = _selectedEquipment
				};
				if (Plugin.Instance.Network.Server)
				{
					SteamNetworkingIdentity sender = default(SteamNetworkingIdentity);
					((SteamNetworkingIdentity)(ref sender)).SetSteamID(Plugin.Instance.PlayerManager.LocalPlayer.SteamID);
					PacketHandler.HandlePacket(sender, weaponResponsePacket);
				}
				else
				{
					Plugin.Instance.Network.Send(weaponResponsePacket);
				}
				Object.Destroy((Object)(object)((Component)this).gameObject);
			};
			Navigation navigation = default(Navigation);
			((Navigation)(ref navigation)).mode = (Mode)4;
			((Navigation)(ref navigation)).selectOnLeft = component7;
			((Navigation)(ref navigation)).selectOnRight = component6;
			((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)_button.Button;
			component5.navigation = navigation;
			navigation = default(Navigation);
			((Navigation)(ref navigation)).mode = (Mode)4;
			((Navigation)(ref navigation)).selectOnLeft = component6;
			((Navigation)(ref navigation)).selectOnRight = component5;
			((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)_button.Button;
			component7.navigation = navigation;
			navigation = default(Navigation);
			((Navigation)(ref navigation)).mode = (Mode)4;
			((Navigation)(ref navigation)).selectOnLeft = component5;
			((Navigation)(ref navigation)).selectOnRight = component7;
			((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)_button.Button;
			component6.navigation = navigation;
			_button.NavUp = component7;
			((Selectable)_button.Button).Select();
			LayoutRebuilder.ForceRebuildLayoutImmediate(val2.GetComponent<RectTransform>());
		}

		private GameObject AddWeaponIcon(GameObject parent, Equipment equipment)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_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_00aa: 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_00d9: 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_0125: 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_0175: 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_0211: 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_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			Color normal = new Color(0.153f, 0.216f, 0.294f, 1f);
			Color selected = new Color(0.106f, 0.322f, 0.584f, 1f);
			Color outlineNormal = new Color(0.784f, 0.651f, 0.455f, 1f);
			Color outlineSelected = new Color(1f, 0.906f, 0.769f, 1f);
			GameObject frame = UIHelper.CreateUIObject($"weapon_{equipment}", parent);
			GameObject icon = UIHelper.CreateUIObject($"weapon_{equipment}", frame);
			TweenScale tweeen = frame.AddComponent<TweenScale>();
			RectTransform component = frame.GetComponent<RectTransform>();
			component.pivot = new Vector2(0.5f, 0.5f);
			component.sizeDelta = new Vector2(64f, 64f);
			MPImageBasic image = frame.AddComponent<MPImageBasic>();
			image.type = (Type)0;
			((Graphic)image).color = normal;
			image.OutlineColor = outlineNormal;
			image.OutlineWidth = 4f;
			((Image)image).fillCenter = true;
			((Image)image).fillMethod = (FillMethod)4;
			((Image)image).fillAmount = 1f;
			image.CircleFitToRect = true;
			image.Shape = (DrawShape)1;
			Button val = frame.AddComponent<Button>();
			((Selectable)val).image = (Image)(object)image;
			ColorBlock colors = default(ColorBlock);
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).pressedColor = Color.white;
			((ColorBlock)(ref colors)).selectedColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = Color.white;
			((ColorBlock)(ref colors)).disabledColor = Color.white;
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0f;
			((Selectable)val).colors = colors;
			frame.AddComponent<EventTrigger>();
			UIHelper.AddEvent(frame, (EventTriggerType)4, delegate
			{
				_selectedEquipment = equipment;
				ThronefallAudioManager.Oneshot((AudioOneShot)11);
				this.OnWeaponChanged?.Invoke();
			});
			UIHelper.AddEvent(frame, (EventTriggerType)15, delegate
			{
				_selectedEquipment = equipment;
				ThronefallAudioManager.Oneshot((AudioOneShot)11);
				this.OnWeaponChanged?.Invoke();
			});
			UIHelper.AddEvent(frame, (EventTriggerType)0, delegate
			{
				Highlight();
			});
			UIHelper.AddEvent(frame, (EventTriggerType)9, delegate
			{
				Highlight();
			});
			UIHelper.AddEvent(frame, (EventTriggerType)1, delegate
			{
				Unhighlight();
			});
			UIHelper.AddEvent(frame, (EventTriggerType)10, delegate
			{
				Unhighlight();
			});
			RectTransform component2 = icon.GetComponent<RectTransform>();
			component2.pivot = new Vector2(0.5f, 0.5f);
			component2.sizeDelta = new Vector2(32f, 32f);
			Image val2 = icon.AddComponent<Image>();
			val2.type = (Type)3;
			val2.sprite = Equip.Convert(equipment).icon;
			((Graphic)val2).color = outlineNormal;
			OnWeaponChanged += delegate
			{
				//IL_0036: 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_005e: 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_0086: 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_00c0: 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)
				Image component3 = icon.GetComponent<Image>();
				MPImageBasic component4 = frame.GetComponent<MPImageBasic>();
				((Graphic)component4).color = ((_selectedEquipment == equipment) ? selected : normal);
				component4.OutlineColor = ((_selectedEquipment == equipment) ? outlineSelected : outlineNormal);
				((Graphic)component3).color = ((_selectedEquipment == equipment) ? outlineSelected : outlineNormal);
				tweeen.Tween((Vector3)((_selectedEquipment != equipment) ? Vector3.one : new Vector3(1.2f, 1.2f, 1.2f)), 0.3f, 0.05f);
			};
			return frame;
			void Highlight()
			{
				//IL_000d: 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)
				image.OutlineColor = outlineSelected;
				tweeen.Tween(new Vector3(1.2f, 1.2f, 1.2f), 0.1f, 0.03f);
			}
			void Unhighlight()
			{
				//IL_0037: 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_0084: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
				image.OutlineColor = ((_selectedEquipment == equipment) ? outlineSelected : outlineNormal);
				Image component3 = icon.GetComponent<Image>();
				((Graphic)component3).color = ((_selectedEquipment == equipment) ? outlineSelected : outlineNormal);
				if (_selectedEquipment != equipment)
				{
					tweeen.Tween(Vector3.one, 0.3f, 0.05f);
				}
			}
		}

		public void OnEnable()
		{
			UIFramePatch.DisableGameUIInputCount++;
			if ((Object)(object)UIFrameManager.instance != (Object)null)
			{
				UIFrameManager.instance.CloseAllFrames();
			}
			if ((Object)(object)LocalGamestate.Instance != (Object)null)
			{
				LocalGamestate.Instance.SetPlayerFreezeState(true);
			}
		}

		public void OnDisable()
		{
			UIFramePatch.DisableGameUIInputCount--;
			if ((Object)(object)LocalGamestate.Instance != (Object)null)
			{
				LocalGamestate.Instance.SetPlayerFreezeState(false);
			}
		}
	}
}
namespace ThronefallMP.UI.Controls
{
	public class ButtonControl : MonoBehaviour
	{
		public struct Style
		{
			public Color Color;

			public float Size;
		}

		public delegate void ButtonEvent();

		public Style Normal = new Style
		{
			Color = UIManager.ButtonTextColor,
			Size = 30f
		};

		public Style Hover = new Style
		{
			Color = UIManager.ButtonHoverTextColor,
			Size = 40f
		};

		public Style NormalSelected = new Style
		{
			Color = UIManager.ButtonTextColor,
			Size = 40f
		};

		public Style HoverSelected = new Style
		{
			Color = UIManager.ButtonHoverTextColor,
			Size = 40f
		};

		public Style Noninteractive = new Style
		{
			Color = UIManager.NoninteractiveButtonTextColor,
			Size = 30f
		};

		private bool _hovering;

		private float _startSize;

		private float _endSize;

		private float _lerpSize;

		public Button Button { get; private set; }

		public TextMeshProUGUI Text { get; private set; }

		public bool Selected { get; private set; }

		public float SizeChangeTime { get; set; } = 0.1f;

		public Selectable NavLeft
		{
			get
			{
				//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)
				Navigation navigation = ((Selectable)Button).navigation;
				return ((Navigation)(ref navigation)).selectOnLeft;
			}
			set
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				Button button = Button;
				Navigation navigation = ((Selectable)Button).navigation;
				((Navigation)(ref navigation)).selectOnLeft = value;
				((Selectable)button).navigation = navigation;
			}
		}

		public Selectable NavRight
		{
			get
			{
				//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)
				Navigation navigation = ((Selectable)Button).navigation;
				return ((Navigation)(ref navigation)).selectOnRight;
			}
			set
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				Button button = Button;
				Navigation navigation = ((Selectable)Button).navigation;
				((Navigation)(ref navigation)).selectOnRight = value;
				((Selectable)button).navigation = navigation;
			}
		}

		public Selectable NavUp
		{
			get
			{
				//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)
				Navigation navigation = ((Selectable)Button).navigation;
				return ((Navigation)(ref navigation)).selectOnUp;
			}
			set
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				Button button = Button;
				Navigation navigation = ((Selectable)Button).navigation;
				((Navigation)(ref navigation)).selectOnUp = value;
				((Selectable)button).navigation = navigation;
			}
		}

		public Selectable NavDown
		{
			get
			{
				//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)
				Navigation navigation = ((Selectable)Button).navigation;
				return ((Navigation)(ref navigation)).selectOnDown;
			}
			set
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				Button button = Button;
				Navigation navigation = ((Selectable)Button).navigation;
				((Navigation)(ref navigation)).selectOnDown = value;
				((Selectable)button).navigation = navigation;
			}
		}

		public event ButtonEvent OnSelected;

		public event ButtonEvent OnDeselected;

		public event ButtonEvent OnEnter;

		public event ButtonEvent OnExit;

		public event ButtonEvent OnClick;

		public void SetInteractable(bool value)
		{
			if (value != ((Selectable)Button).interactable)
			{
				((Selectable)Button).interactable = value;
				Apply(value ? Normal : Noninteractive);
			}
		}

		private void Awake()
		{
			//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_0036: Unknown result type (might be due to invalid IL or missing references)
			Button = ((Component)this).GetComponent<Button>();
			Text = ((Component)this).GetComponentInChildren<TextMeshProUGUI>();
			Button button = Button;
			Navigation navigation = ((Selectable)Button).navigation;
			((Navigation)(ref navigation)).mode = (Mode)4;
			((Selectable)button).navigation = navigation;
			_startSize = Normal.Size;
			_endSize = Normal.Size;
			_lerpSize = 1f;
			Apply(((Selectable)Button).interactable ? Normal : Noninteractive, instant: true);
			UIHelper.AddEvent(((Component)this).gameObject, (EventTriggerType)0, delegate
			{
				if (((Selectable)Button).interactable)
				{
					_hovering = true;
					Apply(Selected ? HoverSelected : Hover);
					this.OnEnter?.Invoke();
				}
			});
			UIHelper.AddEvent(((Component)this).gameObject, (EventTriggerType)1, delegate
			{
				if (((Selectable)Button).interactable)
				{
					_hovering = false;
					Apply(Selected ? NormalSelected : Normal);
					this.OnExit?.Invoke();
				}
			});
			UIHelper.AddEvent(((Component)this).gameObject, (EventTriggerType)9, delegate
			{
				if (((Selectable)Button).interactable)
				{
					Selected = true;
					Apply(_hovering ? HoverSelected : NormalSelected);
					this.OnSelected?.Invoke();
				}
			});
			UIHelper.AddEvent(((Component)this).gameObject, (EventTriggerType)10, delegate
			{
				if (((Selectable)Button).interactable)
				{
					Selected = false;
					Apply(_hovering ? Hover : Normal);
					this.OnDeselected?.Invoke();
				}
			});
			UIHelper.AddEvent(((Component)this).gameObject, (EventTriggerType)4, delegate
			{
				if (((Selectable)Button).interactable)
				{
					this.OnClick?.Invoke();
				}
			});
			UIHelper.AddEvent(((Component)this).gameObject, (EventTriggerType)15, delegate
			{
				if (((Selectable)Button).interactable)
				{
					this.OnClick?.Invoke();
				}
			});
		}

		private void Update()
		{
			if (!(Math.Abs(_startSize - _endSize) < 0.01f))
			{
				_lerpSize = Math.Min(_lerpSize + Time.deltaTime / SizeChangeTime, 1f);
				((TMP_Text)Text).fontSize = Mathf.Lerp(_startSize, _endSize, _lerpSize);
			}
		}

		public void Reset()
		{
			_hovering = false;
			Selected = false;
			Apply(((Selectable)Button).interactable ? Normal : Noninteractive, instant: true);
		}

		private void OnDisable()
		{
			Reset();
		}

		private void Apply(Style style, bool instant = false, bool resetLerp = true)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)Text).color = style.Color;
			_endSize = style.Size;
			if (!instant)
			{
				_startSize = ((TMP_Text)Text).fontSize;
				if (resetLerp)
				{
					_lerpSize = 1f - _lerpSize;
				}
			}
			else
			{
				_lerpSize = 1f;
				_startSize = _endSize;
				((TMP_Text)Text).fontSize = _endSize;
			}
		}
	}
	public class CustomScrollRect : ScrollRect
	{
		private bool _swallowMouseWheelScrolls = true;

		private void Update()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			Player player = ReInput.players.GetPlayer(0);
			float? obj;
			if (player == null)
			{
				obj = null;
			}
			else
			{
				ControllerHelper controllers = player.controllers;
				if (controllers == null)
				{
					obj = null;
				}
				else
				{
					Mouse mouse = controllers.Mouse;
					if (mouse == null)
					{
						obj = null;
					}
					else
					{
						Axis obj2 = ((ControllerWithAxes)mouse).Axes[2];
						obj = ((obj2 != null) ? new float?(obj2.value) : ((float?)null));
					}
				}
			}
			float? num = obj;
			if (num.HasValue)
			{
				PointerEventData val = new PointerEventData(EventSystem.current)
				{
					scrollDelta = new Vector2(0f, num.Value)
				};
				_swallowMouseWheelScrolls = false;
				((ScrollRect)this).OnScroll(val);
				_swallowMouseWheelScrolls = true;
			}
		}

		public override void OnScroll(PointerEventData data)
		{
			if (!_swallowMouseWheelScrolls)
			{
				((ScrollRect)this).OnScroll(data);
			}
		}
	}
	public class LobbyItem : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
	{
		public delegate void HandleClick();

		public GameObject LobbyGameObject;

		public Lobby LobbyInfo;

		public TextMeshProUGUI PlayerCount;

		public event HandleClick OnClick;

		public void OnPointerClick(PointerEventData eventData)
		{
			this.OnClick?.Invoke();
		}
	}
	public class PlayerInfoControl : MonoBehaviour
	{
		private const int GoodPing = 80;

		private const int BadPing = 300;

		public int playerId;

		public GameObject hostIdentifier;

		public GameObject container;

		public TMP_Text playerName;

		public TMP_Text ping;

		private void OnEnable()
		{
			//IL_003d: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			PlayerManager.Player player = Plugin.Instance.PlayerManager.Get(playerId);
			if (player == null)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			hostIdentifier.gameObject.SetActive(player.SteamID == Plugin.Instance.Network.Owner);
			playerName.text = (SteamManager.Initialized ? SteamFriends.GetFriendPersonaName(player.SteamID) : "Unknown");
			OnPingUpdated(player);
			Plugin.Instance.PlayerManager.OnPlayerPingUpdated += OnPingUpdated;
			Plugin.Instance.PlayerManager.OnPlayerRemoved += OnPlayerRemoved;
			Plugin.Instance.Network.OnOwnerChanged += OnOwnerChanged;
		}

		private void OnOwnerChanged(CSteamID owner)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			PlayerManager.Player player = Plugin.Instance.PlayerManager.Get(owner);
			hostIdentifier.gameObject.SetActive(player.Id == playerId);
		}

		private void OnPlayerRemoved(PlayerManager.Player player)
		{
			if (player.Id == playerId)
			{
				Object.Destroy((Object)(object)container);
			}
		}

		private void OnDisable()
		{
			Plugin.Instance.PlayerManager.OnPlayerPingUpdated -= OnPingUpdated;
		}

		private void OnDestroy()
		{
			Plugin.Instance.PlayerManager.OnPlayerRemoved -= OnPlayerRemoved;
			Plugin.Instance.Network.OnOwnerChanged -= OnOwnerChanged;
		}

		private void OnPingUpdated(PlayerManager.Player player)
		{
			//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_0067: Unknown result type (might be due to invalid IL or missing references)
			if (player.Id == playerId)
			{
				ping.text = player.Ping.ToString();
				((Graphic)ping).color = Color.Lerp(Color.green, Color.red, Mathf.Min(Mathf.Max((float)(int)(player.Ping - 80), 0f) / 220f, 1f));
			}
		}
	}
	public class ToggleControl : MonoBehaviour
	{
		public struct Style
		{
			public Color Color;

			public Color BackgroundColor;

			public float FontSize;

			public Style()
			{
				//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_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)
				Color = UIManager.ButtonTextColor;
				BackgroundColor = UIManager.BackgroundColor;
				FontSize = 20f;
			}
		}

		public delegate void ToggleEvent();

		public Style Normal = new Style
		{
			Color = UIManager.ButtonTextColor,
			BackgroundColor = UIManager.BackgroundColor
		};

		public Style Hover = new Style
		{
			Color = UIManager.ButtonHoverTextColor,
			BackgroundColor = UIManager.BackgroundColor
		};

		public Style NormalSelected = new Style
		{
			Color = UIManager.ButtonTextColor,
			BackgroundColor = UIManager.BackgroundColor
		};

		public Style HoverSelected = new Style
		{
			Color = UIManager.ButtonHoverTextColor,
			BackgroundColor = UIManager.BackgroundColor
		};

		public Style Noninteractive = new Style
		{
			Color = UIManager.NoninteractiveButtonTextColor,
			BackgroundColor = UIManager.BackgroundColor
		};

		private int _checkmarkSize;

		private GameObject _checkBorder;

		private GameObject _background;

		private GameObject _check;

		private bool _hovering;

		public Toggle Toggle { get; private set; }

		public TextMeshProUGUI Text { get; private set; }

		public bool Selected { get; private set; }

		public Selectable NavLeft
		{
			get
			{
				//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)
				Navigation navigation = ((Selectable)Toggle).navigation;
				return ((Navigation)(ref navigation)).selectOnLeft;
			}
			set
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				Toggle toggle = Toggle;
				Navigation navigation = ((Selectable)Toggle).navigation;
				((Navigation)(ref navigation)).selectOnLeft = value;
				((Selectable)toggle).navigation = navigation;
			}
		}

		public Selectable NavRight
		{
			get
			{
				//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)
				Navigation navigation = ((Selectable)Toggle).navigation;
				return ((Navigation)(ref navigation)).selectOnRight;
			}
			set
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				Toggle toggle = Toggle;
				Navigation navigation = ((Selectable)Toggle).navigation;
				((Navigation)(ref navigation)).selectOnRight = value;
				((Selectable)toggle).navigation = navigation;
			}
		}

		public Selectable NavUp
		{
			get
			{
				//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)
				Navigation navigation = ((Selectable)Toggle).navigation;
				return ((Navigation)(ref navigation)).selectOnUp;
			}
			set
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				Toggle toggle = Toggle;
				Navigation navigation = ((Selectable)Toggle).navigation;
				((Navigation)(ref navigation)).selectOnUp = value;
				((Selectable)toggle).navigation = navigation;
			}
		}

		public Selectable NavDown
		{
			get
			{
				//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)
				Navigation navigation = ((Selectable)Toggle).navigation;
				return ((Navigation)(ref navigation)).selectOnDown;
			}
			set
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				Toggle toggle = Toggle;
				Navigation navigation = ((Selectable)Toggle).navigation;
				((Navigation)(ref navigation)).selectOnDown = value;
				((Selectable)toggle).navigation = navigation;
			}
		}

		public int CheckmarkSize
		{
			get
			{
				return _checkmarkSize;
			}
			set
			{
				UIHelper.SetLayoutElement(_checkBorder, value, value);
				_checkmarkSize = value;
			}
		}

		public event ToggleEvent OnSelected;

		public event ToggleEvent OnDeselected;

		public event ToggleEvent OnEnter;

		public event ToggleEvent OnExit;

		public event ToggleEvent OnToggledOn;

		public event ToggleEvent OnToggledOff;

		public void SetInteractable(bool value)
		{
			if (value != ((Selectable)Toggle).interactable)
			{
				((Selectable)Toggle).interactable = value;
				Apply(value ? Normal : Noninteractive);
			}
		}

		private void Awake()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Toggle = ((Component)this).GetComponent<Toggle>();
			Text = ((Component)((Component)this).transform).GetComponentInChildren<TextMeshProUGUI>();
			Toggle toggle = Toggle;
			Navigation navigation = ((Selectable)Toggle).navigation;
			((Navigation)(ref navigation)).mode = (Mode)4;
			((Selectable)toggle).navigation = navigation;
			_checkBorder = ((Component)((Component)this).transform.Find("checkmark")).gameObject;
			_background = ((Component)((Component)this).transform.Find("checkmark/background")).gameObject;
			_check = ((Component)((Component)this).transform.Find("checkmark/check")).gameObject;
			_check.SetActive(Toggle.isOn);
			Apply(Normal);
			CheckmarkSize = 20;
			UIHelper.AddEvent(((Component)this).gameObject, (EventTriggerType)0, delegate
			{
				if (((Selectable)Toggle).interactable)
				{
					_hovering = true;
					Apply(Selected ? HoverSelected : Hover);
					this.OnEnter?.Invoke();
				}
			});
			UIHelper.AddEvent(((Component)this).gameObject, (EventTriggerType)1, delegate
			{
				if (((Selectable)Toggle).interactable)
				{
					_hovering = false;
					Apply(Selected ? NormalSelected : Normal);
					this.OnExit?.Invoke();
				}
			});
			UIHelper.AddEvent(((Component)this).gameObject, (EventTriggerType)9, delegate
			{
				if (((Selectable)Toggle).interactable)
				{
					Selected = true;
					Apply(_hovering ? HoverSelected : NormalSelected);
					this.OnSelected?.Invoke();
				}
			});
			UIHelper.AddEvent(((Component)this).gameObject, (EventTriggerType)10, delegate
			{
				if (((Selectable)Toggle).interactable)
				{
					Selected = false;
					Apply(_hovering ? Hover : Normal);
					this.OnDeselected?.Invoke();
				}
			});
			((UnityEvent<bool>)(object)Toggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool value)
			{
				if (((Selectable)Toggle).interactable)
				{
					_check.SetActive(value);
					(value ? this.OnToggledOn : this.OnToggledOff)?.Invoke();
				}
			});
		}

		private void OnDisable()
		{
			_hovering = false;
			Selected = false;
			Apply(Normal);
		}

		private void Apply(Style style)
		{
			//IL_0043: 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_0071: 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)
			if ((Object)(object)Text != (Object)null)
			{
				((Graphic)Text).color = style.Color;
				((TMP_Text)Text).fontSize = style.FontSize;
			}
			((Graphic)_checkBorder.GetComponent<Image>()).color = style.Color;
			((Graphic)_background.GetComponent<Image>()).color = style.BackgroundColor;
			((Graphic)_check.GetComponent<Image>()).color = style.Color;
		}
	}
}
namespace ThronefallMP.Patches
{
	public static class BuildingInteractorPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_OnDawn_AfterSunrise <0>__OnDawn_AfterSunrise;

			public static hook_InteractionHold <1>__InteractionHold;

			public static hook_Update <2>__Update;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			object obj = <>O.<0>__OnDawn_AfterSunrise;
			if (obj == null)
			{
				hook_OnDawn_AfterSunrise val = OnDawn_AfterSunrise;
				<>O.<0>__OnDawn_AfterSunrise = val;
				obj = (object)val;
			}
			BuildingInteractor.OnDawn_AfterSunrise += (hook_OnDawn_AfterSunrise)obj;
			object obj2 = <>O.<1>__InteractionHold;
			if (obj2 == null)
			{
				hook_InteractionHold val2 = InteractionHold;
				<>O.<1>__InteractionHold = val2;
				obj2 = (object)val2;
			}
			BuildingInteractor.InteractionHold += (hook_InteractionHold)obj2;
			object obj3 = <>O.<2>__Update;
			if (obj3 == null)
			{
				hook_Update val3 = Update;
				<>O.<2>__Update = val3;
				obj3 = (object)val3;
			}
			BuildingInteractor.Update += (hook_Update)obj3;
		}

		private static void Update(orig_Update orig, BuildingInteractor self)
		{
			if (self.IsWaitingForChoice && GlobalData.Balance < 0)
			{
				UIFrameManager.instance.CloseActiveFrame();
				ChoiceManager.instance.CancelChoice();
			}
			orig.Invoke(self);
		}

		private static void OnDawn_AfterSunrise(orig_OnDawn_AfterSunrise original, BuildingInteractor self)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			Traverse<List<IncomeModifyer>> val = Traverse.Create((object)self).Field<List<IncomeModifyer>>("incomeModifiers");
			PlayerInteraction[] players = (from x in Plugin.Instance.PlayerManager.GetAllPlayerData()
				select ((Component)x).GetComponent<PlayerInteraction>()).ToArray();
			PlayerInteraction val2 = Helpers.FindClosest(players, ((Component)self).transform.position);
			self.Harvest(val2);
			foreach (IncomeModifyer item in val.Value)
			{
				item.OnDawn();
			}
			self.UpdateInteractionState(false, (InteractionState)0);
		}

		private static void InteractionHold(orig_InteractionHold original, BuildingInteractor self, PlayerInteraction player)
		{
			Traverse.Create((object)player).Field<int>("balance").Value = GlobalData.Balance;
			original.Invoke(self, player);
		}
	}
	public static class BuildSlotPatch
	{
		public struct UpgradeInfo
		{
			public int Cost;

			public int CurrentLevel;
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__Start;

			public static hook_OnUpgradeChoiceComplete <1>__OnUpgradeChoiceComplete;
		}

		public static GameObject CoinPrefab;

		private static bool _disableNetworkHook;

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			object obj = <>O.<0>__Start;
			if (obj == null)
			{
				hook_Start val = Start;
				<>O.<0>__Start = val;
				obj = (object)val;
			}
			BuildSlot.Start += (hook_Start)obj;
			object obj2 = <>O.<1>__OnUpgradeChoiceComplete;
			if (obj2 == null)
			{
				hook_OnUpgradeChoiceComplete val2 = OnUpgradeChoiceComplete;
				<>O.<1>__OnUpgradeChoiceComplete = val2;
				obj2 = (object)val2;
			}
			BuildSlot.OnUpgradeChoiceComplete += (hook_OnUpgradeChoiceComplete)obj2;
		}

		private static void Start(orig_Start original, BuildSlot self)
		{
			original.Invoke(self);
			if ((Object)(object)self.ActivatorBuilding == (Object)null)
			{
				((MonoBehaviour)self).StartCoroutine(ProcessBuildings(self));
			}
		}

		private static IEnumerator ProcessBuildings(BuildSlot root)
		{
			yield return (object)new WaitForEndOfFrame();
			Identifier.Clear(IdentifierType.BuildSlot);
			Identifier.Clear(IdentifierType.Building);
			Identifier.Clear(IdentifierType.Ally);
			Plugin.Log.LogInfo((object)"Processing buildings");
			List<BuildSlot> slots = new List<BuildSlot> { root };
			while (slots.Count > 0)
			{
				BuildSlot current = slots[0];
				slots.Remove(current);
				slots.AddRange(current.IsRootOf);
				ushort buildingId = (ushort)((Component)current).transform.GetSiblingIndex();
				AssignId(current, buildingId);
				UnitRespawnerForBuildings[] componentsInChildren = ((Component)current).GetComponentsInChildren<UnitRespawnerForBuildings>(true);
				foreach (UnitRespawnerForBuildings respawn in componentsInChildren)
				{
					ProcessUnits(respawn, buildingId);
				}
			}
			CoinPrefab = root.buildingInteractor.coinSpawner.coinPrefab;
			if ((Object)(object)TagManager.instance != (Object)null)
			{
				Traverse.Create((object)TagManager.instance).Field<List<TaggedObject>>("bufferedPlayers").Value?.RemoveAll((TaggedObject o) => (Object)(object)o == (Object)null);
			}
		}

		private static void AssignId(BuildSlot self, ushort id)
		{
			Identifier identifier = ((Component)self).gameObject.AddComponent<Identifier>();
			identifier.SetIdentity(IdentifierType.BuildSlot, id);
			Hp componentInChildren = ((Component)self).GetComponentInChildren<Hp>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				Identifier identifier2 = ((Component)componentInChildren).gameObject.AddComponent<Identifier>();
				identifier2.SetIdentity(IdentifierType.Building, id);
			}
		}

		private static void ProcessUnits(UnitRespawnerForBuildings respawn, ushort buildingId)
		{
			for (int i = 0; i < ((Component)respawn).transform.childCount; i++)
			{
				Transform child = ((Component)respawn).transform.GetChild(i);
				Identifier identifier = ((Component)child).gameObject.AddComponent<Identifier>();
				ushort id = (ushort)((buildingId << 7) | (child.parent.GetSiblingIndex() << 4) | child.GetSiblingIndex());
				identifier.SetIdentity(IdentifierType.Ally, id);
			}
		}

		private static void OnUpgradeChoiceComplete(orig_OnUpgradeChoiceComplete original, BuildSlot self, Choice choice)
		{
			//IL_015d: 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_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			Upgrade value = Traverse.Create((object)self).Field<Upgrade>("upgradeSelected").Value;
			if (value == null)
			{
				return;
			}
			if (!_disableNetworkHook && choice != null)
			{
				ushort id = ((Component)self).GetComponent<Identifier>().Id;
				int i;
				for (i = 0; i < self.upgrades.Count && self.upgrades[i] != value; i++)
				{
				}
				int j;
				for (j = 0; j < value.upgradeBranches.Count && value.upgradeBranches[j].choiceDetails != choice; j++)
				{
				}
				if (Plugin.Instance.Network.Server)
				{
					ConfirmBuildPacket basePacket = new ConfirmBuildPacket
					{
						BuildingId = id,
						Level = (byte)i,
						Choice = (byte)j,
						PlayerID = Plugin.Instance.PlayerManager.LocalId
					};
					Plugin.Instance.Network.Send(basePacket, handleLocal: true);
				}
				else
				{
					BuildOrUpgradePacket basePacket2 = new BuildOrUpgradePacket
					{
						BuildingId = id,
						Level = (byte)i,
						Choice = (byte)j
					};
					Plugin.Instance.Network.Send(basePacket2);
				}
			}
			else
			{
				original.Invoke(self, choice);
			}
		}

		public static UpgradeInfo GetUpgradeInfo(ushort id, byte level, byte choice)
		{
			BuildSlot component = Identifier.GetGameObject(IdentifierType.BuildSlot, id).GetComponent<BuildSlot>();
			Upgrade val = component.upgrades[level];
			return new UpgradeInfo
			{
				Cost = val.cost,
				CurrentLevel = component.Level
			};
		}

		public static void HandleUpgrade(ushort playerId, ushort id, byte level, byte choice)
		{
			BuildSlot component = Identifier.GetGameObject(IdentifierType.BuildSlot, id).GetComponent<BuildSlot>();
			if ((Object)(object)component == (Object)null)
			{
				Plugin.Log.LogInfo((object)$"Unable to build {id}:{level}:{choice} for {playerId}");
			}
			if ((Object)(object)component.buildingInteractor == (Object)null)
			{
				Plugin.Log.LogInfo((object)$"Building interactor for {id}:{level}:{choice} inactive");
				component.buildingInteractor = ((Component)component).GetComponentInChildren<BuildingInteractor>(true);
			}
			Upgrade val = component.upgrades[level];
			UpgradeBranch val2 = val.upgradeBranches[choice];
			Traverse<Upgrade> val3 = Traverse.Create((object)component).Field<Upgrade>("upgradeSelected");
			val3.Value = val;
			_disableNetworkHook = true;
			component.buildingInteractor.MarkAsHarvested();
			if (!((Component)component).gameObject.activeSelf)
			{
				((Component)component).gameObject.SetActive(true);
			}
			component.OnUpgradeChoiceComplete(val2.choiceDetails);
			_disableNetworkHook = false;
			val3.Value = null;
			GameObject value = Traverse.Create((object)component).Field<GameObject>("buildingParent").Value;
			BuildingMeshTracker value2 = Traverse.Create((object)component).Field<BuildingMeshTracker>("buildingMeshTracker").Value;
			bool flag = false;
			if ((Object)(object)value2 != (Object)null)
			{
				MeshFusionSource value3 = Traverse.Create((object)value2).Field<MeshFusionSource>("meshFuser").Value;
				flag = (Object)(object)value3 != (Object)null && ((Component)value3).gameObject.activeInHierarchy;
			}
			Plugin.Log.LogInfo((object)$"[BuildDiag] built id={id} lvl={component.Level} byPlayer={playerId} local={Plugin.Instance.PlayerManager.LocalId} bpActive={(Object)(object)value != (Object)null && value.activeInHierarchy} meshTracker={(Object)(object)value2 != (Object)null} fuserActive={flag}");
			Traverse<bool> val4 = Traverse.Create((object)component.buildingInteractor).Field<bool>("focussed");
			if (component.buildingInteractor.IsWaitingForChoice)
			{
				Plugin.Log.LogInfo((object)"Cancel choice");
				UIFrameManager.instance.CloseActiveFrame();
				ChoiceManager.instance.CancelChoice();
			}
			else if (val4.Value)
			{
				if (playerId != Plugin.Instance.PlayerManager.LocalId)
				{
					Plugin.Log.LogInfo((object)"Redo our focus");
					PlayerInteraction component2 = Plugin.Instance.PlayerManager.LocalPlayer.Object.GetComponent<PlayerInteraction>();
					((InteractorBase)component.buildingInteractor).Unfocus(component2);
				}
				else
				{
					Traverse.Create((object)component.buildingInteractor).Method("BuildComplete", Array.Empty<object>()).GetValue();
				}
			}
		}

		public static void CancelBuild(ushort id)
		{
			BuildSlot component = Identifier.GetGameObject(IdentifierType.BuildSlot, id).GetComponent<BuildSlot>();
			component.OnUpgradeChoiceComplete((Choice)null);
		}
	}
	public static class CameraRigPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Update <0>__Update;

			public static hook_TransitionToTarget <1>__TransitionToTarget;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			object obj = <>O.<0>__Update;
			if (obj == null)
			{
				hook_Update val = Update;
				<>O.<0>__Update = val;
				obj = (object)val;
			}
			CameraRig.Update += (hook_Update)obj;
			object obj2 = <>O.<1>__TransitionToTarget;
			if (obj2 == null)
			{
				hook_TransitionToTarget val2 = TransitionToTarget;
				<>O.<1>__TransitionToTarget = val2;
				obj2 = (object)val2;
			}
			CameraRig.TransitionToTarget += (hook_TransitionToTarget)obj2;
		}

		private static void Update(orig_Update original, CameraRig self)
		{
			Traverse<Transform> val = Traverse.Create((object)self).Field<Transform>("cameraTarget");
			PlayerNetworkData playerNetworkData = Plugin.Instance.PlayerManager.LocalPlayer?.Data;
			if ((Object)(object)playerNetworkData != (Object)null)
			{
				val.Value = ((Component)playerNetworkData).transform;
				original.Invoke(self);
			}
		}

		private static IEnumerator TransitionToTarget(orig_TransitionToTarget original, CameraRig self, Transform newTarget, float targetCameraSize)
		{
			Traverse<bool> transitionRunning = Traverse.Create((object)self).Field<bool>("transitionRunning");
			Traverse<float> transitionSpeed = Traverse.Create((object)self).Field<float>("transitionSpeed");
			Traverse<Transform> currentTarget = Traverse.Create((object)self).Field<Transform>("currentTarget");
			List<Camera> cameras = Traverse.Create((object)self).Field<List<Camera>>("cameras").Value;
			transitionRunning.Value = true;
			Vector3 startPosition = ((Component)self).transform.position;
			Quaternion startRotation = ((Component)self).transform.rotation;
			float startCameraSize = ((cameras != null && cameras.Count > 0) ? cameras[0].orthographicSize : targetCameraSize);
			float transitionTime = 0f;
			while ((Object)(object)newTarget != (Object)null && (((Component)self).transform.position != newTarget.position || ((Component)self).transform.rotation != newTarget.rotation))
			{
				transitionTime = Mathf.Clamp(transitionTime, 0f, 1f);
				float num = 3f * Mathf.Pow(transitionTime, 2f) - 2f * Mathf.Pow(transitionTime, 3f);
				((Component)self).transform.position = Vector3.Lerp(startPosition, newTarget.position, num);
				((Component)self).transform.rotation = Quaternion.Lerp(startRotation, newTarget.rotation, num);
				if (cameras != null)
				{
					float size = Mathf.Lerp(startCameraSize, targetCameraSize, num);
					foreach (Camera cam in cameras)
					{
						cam.orthographicSize = size;
					}
				}
				transitionTime += Time.deltaTime * transitionSpeed.Value;
				yield return null;
			}
			if (cameras != null)
			{
				foreach (Camera cam2 in cameras)
				{
					cam2.orthographicSize = targetCameraSize;
				}
			}
			currentTarget.Value = newTarget;
			transitionRunning.Value = false;
		}
	}
	public static class CommandUnitsPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Update <0>__Update;

			public static hook_PlaceCommandedUnitsAndCalculateTargetPositions <1>__PlaceCommandedUnitsAndCalculateTargetPositions;

			public static hook_MakeUnitsInBufferHoldPosition <2>__MakeUnitsInBufferHoldPosition;
		}

		private static readonly List<ETag> GroupMustHave = new List<ETag>();

		private static readonly List<ETag> GroupMayNotHave = new List<ETag>();

		private static readonly List<TaggedObject> GroupResults = new List<TaggedObject>();

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			object obj = <>O.<0>__Update;
			if (obj == null)
			{
				hook_Update val = Update;
				<>O.<0>__Update = val;
				obj = (object)val;
			}
			CommandUnits.Update += (hook_Update)obj;
			object obj2 = <>O.<1>__PlaceCommandedUnitsAndCalculateTargetPositions;
			if (obj2 == null)
			{
				hook_PlaceCommandedUnitsAndCalculateTargetPositions val2 = PlaceCommandedUnitsAndCalculateTargetPositions;
				<>O.<1>__PlaceCommandedUnitsAndCalculateTargetPositions = val2;
				obj2 = (object)val2;
			}
			CommandUnits.PlaceCommandedUnitsAndCalculateTargetPositions += (hook_PlaceCommandedUnitsAndCalculateTargetPositions)obj2;
			object obj3 = <>O.<2>__MakeUnitsInBufferHoldPosition;
			if (obj3 == null)
			{
				hook_MakeUnitsInBufferHoldPosition val3 = MakeUnitsInBufferHoldPosition;
				<>O.<2>__MakeUnitsInBufferHoldPosition = val3;
				obj3 = (object)val3;
			}
			CommandUnits.MakeUnitsInBufferHoldPosition += (hook_MakeUnitsInBufferHoldPosition)obj3;
		}

		private static void Update(orig_Update original, CommandUnits self)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			if (Time.timeScale == 0f)
			{
				return;
			}
			Traverse<List<PathfindMovementPlayerunit>> val = Traverse.Create((object)self).Field<List<PathfindMovementPlayerunit>>("playerUnitsCommanding");
			PlayerNetworkData component = ((Component)self).GetComponent<PlayerNetworkData>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			if (self.commanding)
			{
				HandleCommanding(self, component);
			}
			else
			{
				HandleNotCommanding(self, val.Value, component);
			}
			for (int num = val.Value.Count - 1; num >= 0; num--)
			{
				PathfindMovementPlayerunit val2 = val.Value[num];
				val2.HomePosition = ((Component)self).transform.position;
				if (!((Behaviour)val2).enabled)
				{
					val.Value.RemoveAt(num);
					self.OnUnitRemove(val2);
				}
			}
			self.commandingIndicator.SetActive(val.Value.Count > 0 && !component.SharedData.CommandUnitsButton);
			if (!component.SharedData.CommandUnitsButton && self.rangeIndicator.Active)
			{
				self.rangeIndicator.Deactivate();
			}
			component.SelectAllArmyLast = component.SharedData.SelectAllArmy;
			component.SelectAllMeleeLast = component.SharedData.SelectAllMelee;
			component.SelectAllRangedLast = component.SharedData.SelectAllRanged;
			component.SelectAllHeroesLast = component.SharedData.SelectAllHeroes;
		}

		private static bool GroupKeyPressed(PlayerNetworkData data)
		{
			return (data.SharedData.SelectAllArmy && !data.SelectAllArmyLast) || (data.SharedData.SelectAllMelee && !data.SelectAllMeleeLast) || (data.SharedData.SelectAllRanged && !data.SelectAllRangedLast) || (data.SharedData.SelectAllHeroes && !data.SelectAllHeroesLast);
		}

		private static void TrySelectGroups(CommandUnits self, PlayerNetworkData data, List<PathfindMovementPlayerunit> commanding)
		{
			if (data.SharedData.SelectAllArmy && !data.SelectAllArmyLast)
			{
				SelectGroup(self, data, commanding, null, null);
			}
			if (data.SharedData.SelectAllMelee && !data.SelectAllMeleeLast)
			{
				SelectGroup(self, data, commanding, (ETag)4, (ETag)37);
			}
			if (data.SharedData.SelectAllRanged && !data.SelectAllRangedLast)
			{
				SelectGroup(self, data, commanding, (ETag)5, (ETag)37);
			}
			if (data.SharedData.SelectAllHeroes && !data.SelectAllHeroesLast)
			{
				SelectGroup(self, data, commanding, (ETag)37, null);
			}
		}

		private static void SelectGroup(CommandUnits self, PlayerNetworkData data, List<PathfindMovementPlayerunit> commanding, ETag? mustAlsoHave, ETag? mayNotHave)
		{
			//IL_0041: 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_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			GroupMustHave.Clear();
			GroupMayNotHave.Clear();
			GroupResults.Clear();
			GroupMustHave.Add((ETag)7);
			if (mustAlsoHave.HasValue)
			{
				GroupMustHave.Add(mustAlsoHave.Value);
			}
			if (mayNotHave.HasValue)
			{
				GroupMayNotHave.Add(mayNotHave.Value);
			}
			TagManager.instance.FindAllTaggedObjectsWithTags(GroupResults, GroupMustHave, GroupMayNotHave);
			List<IdentifierData> list = new List<IdentifierData>();
			foreach (TaggedObject groupResult in GroupResults)
			{
				PathfindMovementPlayerunit component = ((Component)groupResult).GetComponent<PathfindMovementPlayerunit>();
				if (!((Object)(object)component == (Object)null))
				{
					Traverse<bool> val = Traverse.Create((object)component).Field<bool>("followingPlayer");
					if (!val.Value && !commanding.Contains(component))
					{
						list.Add(new IdentifierData(((Component)component).GetComponent<Identifier>()));
					}
				}
			}
			if (list.Count > 0)
			{
				Plugin.Instance.Network.Send(new CommandAddPacket
				{
					Player = data.id,
					Units = list
				}, handleLocal: true);
			}
		}

		private static void HandleNotCommanding(CommandUnits self, List<PathfindMovementPlayerunit> commanding, PlayerNetworkData data)
		{
			//IL_0128: 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_01f4: Unknown result type (might be due to invalid IL or missing references)
			Traverse<TagManager> val = Traverse.Create((object)self).Field<TagManager>("tagManager");
			Traverse<Hp> val2 = Traverse.Create((object)self).Field<Hp>("hpPlayer");
			if (data.SharedData.CommandUnitsButton && !data.CommandUnitsButtonLast && !self.rangeIndicator.Active)
			{
				self.rangeIndicator.Activate();
			}
			Traverse<List<PathfindMovementPlayerunit>> val3 = Traverse.Create((object)self).Field<List<PathfindMovementPlayerunit>>("playerUnitsCommanding");
			if (Plugin.Instance.Network.Server && val2.Value.HpValue > 0f)
			{
				TrySelectGroups(self, data, val3.Value);
			}
			if (data.SharedData.CommandUnitsButton && val2.Value.HpValue > 0f)
			{
				if (!Plugin.Instance.Network.Server)
				{
					return;
				}
				List<IdentifierData> list = new List<IdentifierData>();
				foreach (TaggedObject playerUnit in TagManager.instance.PlayerUnits)
				{
					if (val.Value.MeasureDistanceToTaggedObject(playerUnit, ((Component)self).transform.position) <= self.attractRange)
					{
						PathfindMovementPlayerunit component = ((Component)playerUnit).GetComponent<PathfindMovementPlayerunit>();
						Traverse<bool> val4 = Traverse.Create((object)component).Field<bool>("followingPlayer");
						if (!val4.Value && !val3.Value.Contains(component))
						{
							list.Add(new IdentifierData(((Component)component).GetComponent<Identifier>()));
						}
					}
				}
				if (list.Count > 0)
				{
					CommandAddPacket basePacket = new CommandAddPacket
					{
						Player = data.id,
						Units = list
					};
					Plugin.Instance.Network.Send(basePacket, handleLocal: true);
				}
			}
			else if (val3.Value.Count > 0)
			{
				self.commanding = true;
			}
		}

		private static void HandleCommanding(CommandUnits self, PlayerNetworkData data)
		{
			Traverse<Hp> val = Traverse.Create((object)self).Field<Hp>("hpPlayer");
			Traverse<float> val2 = Traverse.Create((object)self).Field<float>("timeSincePlace");
			Traverse<bool> val3 = Traverse.Create((object)self).Field<bool>("switchedToHold");
			if ((data.SharedData.CommandUnitsButton && !data.CommandUnitsButtonLast) || GroupKeyPressed(data) || val.Value.HpValue <= 0f)
			{
				self.PlaceCommandedUnitsAndCalculateTargetPositions(false);
				val2.Value = 0f;
				val3.Value = false;
			}
			if (data.SharedData.CommandUnitsButton && val.Value.HpValue > 0f)
			{
				val2.Value += Time.deltaTime;
				if (val2.Value > self.holdToHoldPositionTime && !val3.Value)
				{
					val3.Value = true;
					self.MakeUnitsInBufferHoldPosition();
				}
			}
			if ((!data.SharedData.CommandUnitsButton && data.CommandUnitsButtonLast) || val.Value.HpValue <= 0f)
			{
				self.commanding = false;
				val2.Value = 0f;
			}
			data.CommandUnitsButtonLast = data.SharedData.CommandUnitsButton;
		}

		private static void PlaceCommandedUnitsAndCalculateTargetPositions(orig_PlaceCommandedUnitsAndCalculateTargetPositions orig, CommandUnits self, bool _smartCommand)
		{
			//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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00d8: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: 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_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: 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_01cc: 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_01db: 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_0202: 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_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: 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_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_0256: 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)
			if (!Plugin.Instance.Network.Server || !self.commanding)
			{
				return;
			}
			Traverse<List<PathfindMovementPlayerunit>> val = Traverse.Create((object)self).Field<List<PathfindMovementPlayerunit>>("playerUnitsCommanding");
			Traverse<AstarPath> val2 = Traverse.Create((object)self).Field<AstarPath>("astarPath");
			Traverse<NNConstraint> val3 = Traverse.Create((object)self).Field<NNConstraint>("nearestConstraint");
			Vector3 val5 = default(Vector3);
			for (int i = 0; i < val.Value.Count; i++)
			{
				Vector3 val4 = Quaternion.AngleAxis(360f * (float)i / (float)val.Value.Count, Vector3.up) * Vector3.right * self.unitDistanceMoveStep;
				((Vector3)(ref val5))..ctor(Random.value - 0.5f, 0f, Random.value - 0.5f);
				val.Value[i].HomePosition = val2.Value.GetNearest(((Component)self).transform.position + val4 + val5 * self.unitDistanceMoveStep * 0.1f, val3.Value).position;
			}
			for (int j = 0; j < self.maxPositioningRepeats; j++)
			{
				bool flag = false;
				for (int k = 0; k < val.Value.Count; k++)
				{
					for (int l = k + 1; l < val.Value.Count; l++)
					{
						Vector3 val6 = val.Value[k].HomePosition - val.Value[l].HomePosition;
						if (((Vector3)(ref val6)).sqrMagnitude <= self.unitDistanceFromEachOther * self.unitDistanceFromEachOther)
						{
							Vector3 val7 = val.Value[k].HomePosition - val.Value[l].HomePosition;
							Vector3 val8 = ((Vector3)(ref val7)).normalized * self.unitDistanceMoveStep;
							val.Value[k].HomePosition = val2.Value.GetNearest(val.Value[k].HomePosition + val8, val3.Value).position;
							val.Value[l].HomePosition = val2.Value.GetNearest(val.Value[l].HomePosition - val8, val3.Value).position;
							flag = true;
						}
					}
				}
				if (!flag)
				{
					break;
				}
			}
			Traverse<List<PathfindMovementPlayerunit>> val9 = Traverse.Create((object)self).Field<List<PathfindMovementPlayerunit>>("playerUnitsCommandingBuffer");
			val9.Value.Clear();
			val9.Value.AddRange(val.Value);
			Identifier component = ((Component)self).GetComponent<Identifier>();
			CommandPlacePacket commandPlacePacket = new CommandPlacePacket
			{
				Player = component.Id
			};
			foreach (PathfindMovementPlayerunit item in val.Value)
			{
				commandPlacePacket.Units.Add(new CommandPlacePacket.UnitData
				{
					Unit = new IdentifierData(((Component)item).GetComponent<Identifier>()),
					Home = item.HomePosition
				});
			}
			Plugin.Instance.Network.Send(commandPlacePacket, handleLocal: true);
		}

		private static void MakeUnitsInBufferHoldPosition(orig_MakeUnitsInBufferHoldPosition orig, CommandUnits self)
		{
			//IL_0099: 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_00d4: 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)
			if (!Plugin.Instance.Network.Server)
			{
				return;
			}
			PlayerNetworkData component = ((Component)self).GetComponent<PlayerNetworkData>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			CommandHoldPositionPacket commandHoldPositionPacket = new CommandHoldPositionPacket();
			commandHoldPositionPacket.Player = component.id;
			Traverse<List<PathfindMovementPlayerunit>> val = Traverse.Create((object)self).Field<List<PathfindMovementPlayerunit>>("playerUnitsCommandingBuffer");
			foreach (PathfindMovementPlayerunit item in val.Value)
			{
				commandHoldPositionPacket.Units.Add(new CommandHoldPositionPacket.UnitData
				{
					Unit = new IdentifierData(((Component)item).GetComponent<Identifier>()),
					Home = item.HomePosition
				});
			}
			Plugin.Instance.Network.Send(commandHoldPositionPacket, handleLocal: true);
		}

		public static void EmitWaypoint(CommandUnits self, bool playSound)
		{
			//IL_0060: 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)
			Traverse<ThronefallAudioManager> val = Traverse.Create((object)self).Field<ThronefallAudioManager>("audioManager");
			if (playSound)
			{
				Traverse<AudioSet> val2 = Traverse.Create((object)self).Field<AudioSet>("audioSet");
				val.Value.PlaySoundAsOneShot(val2.Value.PlaceCommandingUnits, 0.35f, 0.9f + Random.value * 0.2f, val.Value.mgSFX, 10, false, default(Vector3));
			}
			self.dropWaypointFx.Emit(self.drowWaypointParticleCount);
		}

		public static void PlaceUnit(CommandUnits self, PathfindMovementPlayerunit unit, Vector3 home)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			self.OnUnitRemove(unit);
			AutoAttack[] components = ((Component)unit).GetComponents<AutoAttack>();
			foreach (AutoAttack val in components)
			{
				if (((Component)val).GetComponent<Hp>().HpValue > 0f)
				{
					((Behaviour)val).enabled = true;
				}
			}
			unit.HomePosition = home;
			Traverse<List<PathfindMovementPlayerunit>> val2 = Traverse.Create((object)self).Field<List<PathfindMovementPlayerunit>>("playerUnitsCommanding");
			val2.Value.Remove(unit);
		}

		public static void PlayHoldSound(CommandUnits self)
		{
			//IL_005a: 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)
			Traverse<ThronefallAudioManager> val = Traverse.Create((object)self).Field<ThronefallAudioManager>("audioManager");
			Traverse<AudioSet> val2 = Traverse.Create((object)self).Field<AudioSet>("audioSet");
			val.Value.PlaySoundAsOneShot(val2.Value.HoldPosition, 0.45f, 0.9f + Random.value * 0.2f, val.Value.mgSFX, 10, false, default(Vector3));
		}

		public static void HoldPosition(PathfindMovementPlayerunit unit, Vector3 home)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			unit.HomePosition = home;
			unit.HoldPosition = true;
		}

		public static void AddUnit(CommandUnits self, PathfindMovementPlayerunit unit)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			Traverse<ThronefallAudioManager> val = Traverse.Create((object)self).Field<ThronefallAudioManager>("audioManager");
			Traverse<AudioSet> val2 = Traverse.Create((object)self).Field<AudioSet>("audioSet");
			Traverse<List<PathfindMovementPlayerunit>> val3 = Traverse.Create((object)self).Field<List<PathfindMovementPlayerunit>>("playerUnitsCommanding");
			Traverse<PlayerUpgradeManager> val4 = Traverse.Create((object)self).Field<PlayerUpgradeManager>("playerUPgradeManager");
			if (val3.Value.Contains(unit))
			{
				return;
			}
			val.Value.PlaySoundAsOneShot(val2.Value.AddedUnitToCommanding, 0.55f, 0.7f + (float)val3.Value.Count * 0.025f, val.Value.mgSFX, 50, false, default(Vector3));
			val3.Value.Add(unit);
			unit.FollowPlayer(true);
			MaterialFlasherFX componentInChildren = ((Component)unit).GetComponentInChildren<MaterialFlasherFX>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				componentInChildren.SetSelected(true);
			}
			((Component)unit).GetComponent<TaggedObject>().Tags.Add((ETag)22);
			Traverse<bool> val5 = Traverse.Create((object)self).Field<bool>("royalProtectionEquipped");
			if (val5.Value)
			{
				Traverse<float> val6 = Traverse.Create((object)self).Field<float>("royalProtectionHealthMulti");
				((Component)unit).GetComponent<Hp>().ScaleHp(val6.Value);
			}
			if (val4.Value.commander)
			{
				unit.movementSpeed *= self.commanderUnitMoveSpeedMulti;
				return;
			}
			AutoAttack[] components = ((Component)unit).GetComponents<AutoAttack>();
			foreach (AutoAttack val7 in components)
			{
				((Behaviour)val7).enabled = false;
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal static class CommandUnitsShouldShowUnitTypesPatch
	{
		private static bool Prefix(CommandUnits __instance, ref bool __result)
		{
			if ((Object)(object)__instance.rangeIndicator == (Object)null || (Object)(object)__instance.commandingIndicator == (Object)null)
			{
				__result = false;
				return false;
			}
			return true;
		}
	}
	public class CostDisplayPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Deny <0>__Deny;

			public static hook_CancelFill <1>__CancelFill;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			object obj = <>O.<0>__Deny;
			if (obj == null)
			{
				hook_Deny val = Deny;
				<>O.<0>__Deny = val;
				obj = (object)val;
			}
			CostDisplay.Deny += (hook_Deny)obj;
			object obj2 = <>O.<1>__CancelFill;
			if (obj2 == null)
			{
				hook_CancelFill val2 = CancelFill;
				<>O.<1>__CancelFill = val2;
				obj2 = (object)val2;
			}
			CostDisplay.CancelFill += (hook_CancelFill)obj2;
		}

		private static void Deny(orig_Deny original, CostDisplay self)
		{
			Traverse<List<Coinslot>> val = Traverse.Create((object)self).Field<List<Coinslot>>("currentlyActiveCoinslots");
			Traverse<int> val2 = Traverse.Create((object)self).Field<int>("currentlyFilledCoins");
			if (GlobalData.Balance < 0 && val.Value.Count > 0)
			{
				val.Value[val2.Value].SetEmpty();
			}
			while (GlobalData.Balance < 0 && val2.Value > 0)
			{
				val2.Value -= 1;
				val.Value[val2.Value].SetEmpty();
				GlobalData.Balance++;
			}
			original.Invoke(self);
		}

		private static void CancelFill(orig_CancelFill original, CostDisplay self, PlayerInteraction player)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			Traverse<List<Coinslot>> val = Traverse.Create((object)self).Field<List<Coinslot>>("currentlyActiveCoinslots");
			foreach (Coinslot item in val.Value)
			{
				if (item.isFull)
				{
					Object.Instantiate<GameObject>(BuildSlotPatch.CoinPrefab, ((Component)item).transform.position, ((Component)item).transform.rotation).GetComponent<Coin>().SetTarget(player);
					num++;
				}
				item.SetEmpty();
			}
			if (!Plugin.Instance.Network.Server)
			{
				GlobalData.Balance += num;
			}
			Traverse<int> val2 = Traverse.Create((object)self).Field<int>("currentlyFilledCoins");
			Traverse<bool> val3 = Traverse.Create((object)self).Field<bool>("denied");
			ThronefallAudioManager.Oneshot((AudioOneShot)5);
			val2.Value = 0;
			CostDisplay.currentlyFilledCoinsFromLastActiveDisplay = 0;
			val3.Value = false;
		}
	}
	public static class DayNightCyclePatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Update <0>__Update;

			public static hook_DawnCallAfterSunrise <1>__DawnCallAfterSunrise;

			public static hook_DawnCallBeforeSunrise <2>__DawnCallBeforeSunrise;

			public static hook_DuskCall <3>__DuskCall;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//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_007f: Expected O, but got Unknown
			object obj = <>O.<0>__Update;
			if (obj == null)
			{
				hook_Update val = Update;
				<>O.<0>__Update = val;
				obj = (object)val;
			}
			DayNightCycle.Update += (hook_Update)obj;
			object obj2 = <>O.<1>__DawnCallAfterSunrise;
			if (obj2 == null)
			{
				hook_DawnCallAfterSunrise val2 = DawnCallAfterSunrise;
				<>O.<1>__DawnCallAfterSunrise = val2;
				obj2 = (object)val2;
			}
			DayNightCycle.DawnCallAfterSunrise += (hook_DawnCallAfterSunrise)obj2;
			object obj3 = <>O.<2>__DawnCallBeforeSunrise;
			if (obj3 == null)
			{
				hook_DawnCallBeforeSunrise val3 = DawnCallBeforeSunrise;
				<>O.<2>__DawnCallBeforeSunrise = val3;
				obj3 = (object)val3;
			}
			DayNightCycle.DawnCallBeforeSunrise += (hook_DawnCallBeforeSunrise)obj3;
			object obj4 = <>O.<3>__DuskCall;
			if (obj4 == null)
			{
				hook_DuskCall val4 = DuskCall;
				<>O.<3>__DuskCall = val4;
				obj4 = (object)val4;
			}
			DayNightCycle.DuskCall += (hook_DuskCall)obj4;
		}

		private static void Update(orig_Update original, DayNightCycle self)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.Instance.Network.Server || (int)LocalGamestate.Instance.CurrentState != 1 || (int)self.CurrentTimestate != 1)
			{
				return;
			}
			Traverse<float> val = Traverse.Create((object)self).Field<float>("currentNightLength");
			val.Value += Time.deltaTime;
			if (Object.op_Implicit((Object)(object)TagManager.instance) && Object.op_Implicit((Object)(object)EnemySpawner.instance) && !EnemySpawner.instance.SpawningInProgress && TagManager.instance.CountAllTaggedObjectsWithTag((ETag)1) < 1 && ((Component)self).gameObject.activeInHierarchy)
			{
				Plugin.Log.LogInfo((object)"Sending DayNightPacket.Day");
				Plugin.Instance.Network.Send(new DayNightPacket
				{
					Timestate = (Timestate)0,
					NightLength = val.Value
				}, handleLocal: true);
				if (EnemySpawner.instance.MatchOver)
				{
					Plugin.Instance.Network.Send(new VictoryPacket(), handleLocal: true);
				}
			}
		}

		private static void DawnCallAfterSunrise(orig_DawnCallAfterSunrise original, DayNightCycle self)
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			Traverse<bool> val = Traverse.Create((object)self).Field<bool>("afterSunrise");
			Traverse<List<IDaytimeSensitive>> val2 = Traverse.Create((object)self).Field<List<IDaytimeSensitive>>("daytimeSensitiveObjects");
			val.Value = true;
			Hp.ReviveAllKnockedOutPlayerUnitsAndBuildings();
			for (int num = val2.Value.Count - 1; num >= 0; num--)
			{
				if (Helpers.UnityNullCheck(val2.Value[num]))
				{
					val2.Value[num].OnDawn_AfterSunrise();
				}
				else
				{
					val2.Value.RemoveAt(num);
				}
			}
			ThronefallAudioManager.Oneshot((AudioOneShot)7);
			LevelData levelDataForActiveScene = LevelProgressManager.instance.GetLevelDataForActiveScene();
			int netWorth = GlobalData.NetWorth;
			netWorth += TagManager.instance.freeCoins.Count;
			netWorth += self.CoinCountToBeHarvested;
			levelDataForActiveScene.dayToDayNetworth.Add(netWorth);
			PlayerInteraction[] players = (from x in Plugin.Instance.PlayerManager.GetAllPlayerData()
				select ((Component)x).GetComponent<PlayerInteraction>()).ToArray();
			foreach (Coin freeCoin in TagManager.instance.freeCoins)
			{
				PlayerInteraction target = Helpers.FindClosest(players, ((Component)freeCoin).transform.position);
				if (freeCoin.IsFree)
				{
					freeCoin.SetTarget(target);
				}
			}
		}

		private static void DawnCallBeforeSunrise(orig_DawnCallBeforeSunrise original, DayNightCycle self)
		{
			Traverse<bool> val = Traverse.Create((object)self).Field<bool>("afterSunrise");
			Traverse<List<IDaytimeSensitive>> val2 = Traverse.Create((object)self).Field<List<IDaytimeSensitive>>("daytimeSensitiveObjects");
			val.Value = false;
			for (int num = val2.Value.Count - 1; num >= 0; num--)
			{
				if (Helpers.UnityNullCheck(val2.Value[num]))
				{
					val2.Value[num].OnDawn_BeforeSunrise();
				}
				else
				{
					val2.Value.RemoveAt(num);
				}
			}
			ThronefallAudioManager.Oneshot((AudioOneShot)6);
		}

		private static void DuskCall(orig_DuskCall original, DayNightCycle self)
		{
			Traverse<bool> val = Traverse.Create((object)self).Field<bool>("afterSunrise");
			Traverse<float> val2 = Traverse.Create((object)self).Field<float>("currentNightLength");
			Traverse<List<IDaytimeSensitive>> val3 = Traverse.Create((object)self).Field<List<IDaytimeSensitive>>("daytimeSensitiveObjects");
			val.Value = false;
			val2.Value = 0f;
			for (int num = val3.Value.Count - 1; num >= 0; num--)
			{
				if (Helpers.UnityNullCheck(val3.Value[num]))
				{
					val3.Value[num].OnDusk();
				}
				else
				{
					val3.Value.RemoveAt(num);
				}
			}
			original.Invoke(self);
		}
	}
	public class EnemySpawnerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__Start;

			public static hook_Update <1>__Update;

			public static hook_OnStartOfTheDay <2>__OnStartOfTheDay;

			public static hook_OnSave <3>__OnSave;

			public static hook_OnLoad <4>__OnLoad;
		}

		private static int _nextEnemyId;

		private static int? _loadedBalance;

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//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_007f: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			object obj = <>O.<0>__Start;
			if (obj == null)
			{
				hook_Start val = Start;
				<>O.<0>__Start = val;
				obj = (object)val;
			}
			EnemySpawner.Start += (hook_Start)obj;
			object obj2 = <>O.<1>__Update;
			if (obj2 == null)
			{
				hook_Update val2 = Update;
				<>O.<1>__Update = val2;
				obj2 = (object)val2;
			}
			EnemySpawner.Update += (hook_Update)obj2;
			object obj3 = <>O.<2>__OnStartOfTheDay;
			if (obj3 == null)
			{
				hook_OnStartOfTheDay val3 = OnStartOfTheDay;
				<>O.<2>__OnStartOfTheDay = val3;
				obj3 = (object)val3;
			}
			EnemySpawner.OnStartOfTheDay += (hook_OnStartOfTheDay)obj3;
			object obj4 = <>O.<3>__OnSave;
			if (obj4 == null)
			{
				hook_OnSave val4 = OnSave;
				<>O.<3>__OnSave = val4;
				obj4 = (object)val4;
			}
			EnemySpawner.OnSave += (hook_OnSave)obj4;
			object obj5 = <>O.<4>__OnLoad;
			if (obj5 == null)
			{
				hook_OnLoad val5 = OnLoad;
				<>O.<4>__OnLoad = val5;
				obj5 = (object)val5;
			}
			EnemySpawner.OnLoad += (hook_OnLoad)obj5;
		}

		private static void OnSave(orig_OnSave original, EnemySpawner self, string guid)
		{
			original.Invoke(self, guid);
			int balance = GlobalData.Internal.Balance;
			MatchSaveLoadHandler.SaveValue(guid, "mpSharedBalance", balance);
			Plugin.Log.LogInfo((object)$"[GoldDiag] saved mpSharedBalance={balance} wave={self.Wavenumber}");
		}

		private static void OnLoad(orig_OnLoad original, EnemySpawner self, string guid)
		{
			original.Invoke(self, guid);
			int value = 0;
			_loadedBalance = (MatchSaveLoadHandler.TryLoadValue<int>(guid, "mpSharedBalance", ref value) ? new int?(value) : ((int?)null));
		}

		private static void Start(orig_Start original, EnemySpawner self)
		{
			bool value = Traverse.Create((object)self).Field<bool>("loadedBalanceFromSave").Value;
			int goldBalanceAtStart = self.goldBalanceAtStart;
			int? loadedBalance = _loadedBalance;
			_loadedBalance = null;
			self.goldBalanceAtStart = 0;
			original.Invoke(self);
			int goldBalanceAtStart2 = self.goldBalanceAtStart;
			self.goldBalanceAtStart = goldBalanceAtStart + goldBalanceAtStart2;
			GlobalData.LocalBalanceDelta = 0;
			if (!Plugin.Instance.Network.Server)
			{
				return;
			}
			if (value)
			{
				if (!loadedBalance.HasValue)
				{
					Plugin.Log.LogWarning((object)"Level loaded from save but no restored balance was captured.");
				}
				Plugin.Log.LogInfo((object)$"Restoring dawn-save balance {loadedBalance.GetValueOrDefault()}");
				GlobalData.Internal.Balance = loadedBalance.GetValueOrDefault();
				GlobalData.Internal.NetWorth = 0;
			}
			else
			{
				Plugin.Log.LogInfo((object)$"Give starting balance {goldBalanceAtStart + goldBalanceAtStart2}");
				GlobalData.Internal.Balance = goldBalanceAtStart + goldBalanceAtStart2;
				GlobalData.Internal.NetWorth = goldBalanceAtStart + goldBalanceAtStart2;
			}
		}

		private static void OnStartOfTheDay(orig_OnStartOfTheDay original, EnemySpawner self)
		{
			Identifier.Clear(IdentifierType.Enemy);
			_nextEnemyId = 0;
			Traverse<bool> val = Traverse.Create((object)self).Field<bool>("treasureHunterActive");
			bool value = val.Value;
			val.Value = false;
			original.Invoke(self);
			val.Value = value;
			int num = default(int);
			if (value && Plugin.Instance.Network.Server && self.GetTreasureHunterBonus(self.Wavenumber, ref num))
			{
				GlobalData.Balance += num;
			}
		}

		private static void Update(orig_Update original, EnemySpawner self)
		{
			Traverse<int> val = Traverse.Create((object)self).Field<int>("numberOfEnemiesOnTheMap");
			if (!self.SpawningInProgress)
			{
				val.Value = TagManager.instance.CountAllTaggedObjectsWithTag((ETag)1);
				return;
			}
			Traverse<float> val2 = Traverse.Create((object)self).Field<float>("lastSpawnPeriodDuration");
			val2.Value += Time.deltaTime;
			if (val.Value < Traverse.Create((object)self).Field<int>("pauseSpawningAtEnemyCount").Value)
			{
				if (Plugin.Instance.Network.Server)
				{
					for (int i = 0; i < self.waves[self.Wavenumber].spawns.Count; i++)
					{
						UpdateSpawn(self.waves[self.Wavenumber].spawns[i], self.Wavenumber, i);
					}
				}
				if (self.waves[self.Wavenumber].HasFinished())
				{
					if (!self.InfinitelySpawning)
					{
						self.StopSpawnAfterWaveAndReset();
					}
					else if (TagManager.instance.CountAllTaggedObjectsWithTag((ETag)1) <= 0)
					{
						foreach (Spawn spawn in self.waves[self.Wavenumber].spawns)
						{
							spawn.Reset(false);
						}
					}
				}
			}
			val.Value = TagManager.instance.CountAllTaggedObjectsWithTag((ETag)1);
			if (val.Value <= 0)
			{
				self.waves[self.Wavenumber].ReduceMaxDelayTillNextSpawn();
			}
		}

		internal static ushort AllocateEnemyId()
		{
			return (ushort)_nextEnemyId++;
		}

		internal static Vector3 RollSpawnPosition(Spawn self)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_00b3: 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_008e: 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_0093: 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)
			List<ETag> tags = self.enemyPrefab.GetComponentInChildren<TaggedObject>().Tags;
			bool flag = tags.Contains((ETag)6);
			bool flag2 = tags.Contains((ETag)41);
			Vector3 val = self.GetRandomPointOnSpawnLine(flag, flag2 ? EnemySpawner.instance.groundConstraintLarge : (flag ? EnemySpawner.instance.flyingConstraint : EnemySpawner.instance.groundConstraint));
			if (PerkManager.instance.GodOfChaosEquipped && !tags.Contains((ETag)42))
			{
				val = Vector3.Lerp(val, CastleCenter.CastleCenterPosition + (flag ? (Vector3.up * 5f) : Vector3.zero), (float)(self.SpawnedUnits % 5) / 5f);
			}
			return val;
		}

		private static void UpdateSpawn(Spawn self, int waveNumber, int spawnIndex)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//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_0111: 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)
			Traverse<bool> val = Traverse.Create((object)self).Field<bool>("finished");
			if (val.Value)
			{
				return;
			}
			Traverse<float> val2 = Traverse.Create((object)self).Field<float>("waitBeforeNextSpawn");
			val2.Value -= Time.deltaTime;
			if (!(val2.Value > 0f))
			{
				val2.Value = self.interval;
				Vector3 position = RollSpawnPosition(self);
				int num = 0;
				Traverse<int> val3 = Traverse.Create((object)self).Field<int>("spawnedUnits");
				Traverse<int[]> val4 = Traverse.Create((object)self).Field<int[]>("goldCoinsPerEnemy");
				if (val4.Value.Length > val3.Value)
				{
					num = val4.Value[val3.Value];
				}
				EnemySpawnPacket basePacket = new EnemySpawnPacket
				{
					Wave = (byte)waveNumber,
					Spawn = (byte)spawnIndex,
					Id = AllocateEnemyId(),
					Position = position,
					Coins = (byte)num,
					Elite = self.eliteEnemies
				};
				Plugin.Instance.Network.Send(basePacket, handleLocal: true);
			}
		}

		public static void SpawnEnemy(int waveNumber, int spawnIndex, Vector3 position, ushort id, int coins, bool elite)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			Wave val = EnemySpawner.instance.waves[waveNumber];
			SpawnEnemy(val.spawns[spawnIndex], val.difficultyMulti, position, id, coins, elite);
		}

		public static void SpawnEnemy(Spawn self, float difficultyMulti, Vector3 position, ushort id, int coins, bool elite)
		{
			//IL_0060: 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_009b: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			GameObject val;
			if ((Object)(object)self.spawnLine == (Object)(object)self.enemyPrefab.transform)
			{
				val = self.enemyPrefab;
				val.SetActive(true);
				Identifier identifier = default(Identifier);
				if (!val.TryGetComponent<Identifier>(ref identifier))
				{
					identifier = val.AddComponent<Identifier>();
					identifier.SetIdentity(IdentifierType.Enemy, id);
				}
			}
			else
			{
				val = Object.Instantiate<GameObject>(self.enemyPrefab, position, Quaternion.identity);
				val.AddComponent<Identifier>().SetIdentity(IdentifierType.Enemy, id);
				EnemySpawnManager instance = EnemySpawnManager.instance;
				if (Object.op_Implicit((Object)(object)instance.weaponOnSpawn))
				{
					instance.weaponOnSpawn.Attack(position + Vector3.up * instance.weaponAttackHeight, (Hp)null, Vector3.forward, val.GetComponent<TaggedObject>(), 1f, 1f);
				}
			}
			Hp componentInChildren = val.GetComponentInChildren<Hp>();
			componentInChildren.coinCount = coins;
			List<ETag> tags = val.GetComponentInChildren<TaggedObject>().Tags;
			Spawn.AdjustEnemyParametersAfterSpawn(val, elite);
			componentInChildren.maxHp *= difficultyMulti;
			componentInChildren.SetHpToMaxHp();
			float num = Mathf.Lerp(1f, difficultyMulti, 0.5f);
			bool flag = PerkManager.instance.GodOfChaosEquipped && !tags.Contains((ETag)42);
			AutoAttack[] componentsInChildren = val.GetComponentsInChildren<AutoAttack>();
			foreach (AutoAttack val2 in componentsInChildren)
			{
				if (flag)
				{
					val2.SetCooldownTo(3f);
				}
				val2.DamageMultiplyer *= num;
			}
			if (Plugin.Instance.Network.Server && PerkManager.instance.GodOfAfterlifeEquipped && self.SpawnedUnits % 2 == 0 && tags.Contains((ETag)40))
			{
				componentInChildren.enemyToSpawnOnDeath = PerkManager.instance.godOfAfterlifeEnemy;
			}
			Traverse<int> val3 = Traverse.Create((object)self).Field<int>("spawnedUnits");
			int value = val3.Value;
			val3.Value = value + 1;
			if (val3.Value >= self.count)
			{
				Traverse.Create((object)self).Field<bool>("finished").Value = true;
			}
		}
	}
	[HarmonyPatch(typeof(Equippable), "get_IsUnlocked")]
	public static class EquippableIsUnlockedPatch
	{
		private static void Postfix(Equippable __instance, ref bool __result)
		{
			if (__result)
			{
				return;
			}
			ThronefallMP.Network.Network network = Plugin.Instance?.Network;
			if (!((Object)(object)network == (Object)null) && network.Online && !network.Server && SceneTransitionManagerPatch.InLevelSelect)
			{
				Equipment equipment = Equip.Convert(((Object)__instance).name);
				if (equipment != Equipment.Invalid && HostUnlocks.Session.Contains(equipment))
				{
					__result = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(FreezePositionOnEnable), "Update")]
	public static class FreezePositionOnEnablePatch
	{
		[HarmonyPrefix]
		private static bool Update(FreezePositionOnEnable __instance)
		{
			return (Object)(object)Traverse.Create((object)__instance).Field<Transform>("oldParent").Value != (Object)null;
		}
	}
	public static class GateOpenerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Update <0>__Update;
		}

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

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			object obj = <>O.<0>__Update;
			if (obj == null)
			{
				hook_Update val = Update;
				<>O.<0>__Update = val;
				obj = (object)val;
			}
			GateOpener.Update += (hook_Update)obj;
		}

		private static void Update(orig_Update original, GateOpener self)
		{
			if (!Object.op_Implicit((Object)(object)TagManager.instance))
			{
				return;
			}
			TagManager instance = TagManager.instance;
			List<TaggedObject> list = new List<TaggedObject>();
			foreach (TaggedObject playerUnit in instance.PlayerUnits)
			{
				if ((Object)(object)playerUnit != (Object)null && (Object)(object)((Component)playerUnit).GetComponent<PathfindMovementPlayerunit>() != (Object)null)
				{
					list.Add(playerUnit);
				}
			}
			Traverse.Create((object)self).Field<IReadOnlyList<TaggedObject>>("players").Value = instance.Players;
			Traverse.Create((object)self).Field<IReadOnlyList<TaggedObject>>("playerUnits").Value = list;
			Traverse<List<TaggedObject>> val = Traverse.Create((object)instance).Field<List<TaggedObject>>("bufferedPlayerUnits");
			List<TaggedObject> value = val.Value;
			val.Value = list;
			try
			{
				original.Invoke(self);
			}
			catch (Exception ex)
			{
				if (_loggedGates.Add(((Object)self).GetInstanceID()))
				{
					Traverse val2 = Traverse.Create((object)self);
					Transform value2 = val2.Field<Transform>("doorL").Value;
					Transform value3 = val2.Field<Transform>("doorR").Value;
					Plugin.Log.LogWarning((object)("[GateDiag] " + ex.GetType().Name + " in gate '" + ((Object)((Component)self).gameObject).name + "' " + string.Format("mode={0} open={1} ", val2.Field("mode").GetValue(), val2.Field("open").GetValue()) + "doorL=" + (((Object)(object)value2 != (Object)null) ? "ok" : "null/destroyed") + " doorR=" + (((Object)(object)value3 != (Object)null) ? "ok" : "null/destroyed") + " " + $"players={((instance.Players != null) ? instance.Players.Count : (-1))} units={list.Count}: {ex.Message}"));
				}
			}
			finally
			{
				val.Value = value;
			}
		}
	}
	public static class HpPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_TakeDamage <0>__TakeDamage;

			public static hook_ScaleHp <1>__ScaleHp;

			public static hook_Heal <2>__Heal;

			public static hook_SetHpToMaxHp <3>__SetHpToMaxHp;
		}

		public static bool AllowHealthChangeOnClient;

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//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_007f: Expected O, but got Unknown
			object obj = <>O.<0>__TakeDamage;
			if (obj == null)
			{
				hook_TakeDamage val = TakeDamage;
				<>O.<0>__TakeDamage = val;
				obj = (object)val;
			}
			Hp.TakeDamage += (hook_TakeDamage)obj;
			object obj2 = <>O.<1>__ScaleHp;
			if (obj2 == null)
			{
				hook_ScaleHp val2 = ScaleHp;
				<>O.<1>__ScaleHp = val2;
				obj2 = (object)val2;
			}
			Hp.ScaleHp += (hook_ScaleHp)obj2;
			object obj3 = <>O.<2>__Heal;
			if (obj3 == null)
			{
				hook_Heal val3 = Heal;
				<>O.<2>__Heal = val3;
				obj3 = (object)val3;
			}
			Hp.Heal += (hook_Heal)obj3;
			object obj4 = <>O.<3>__SetHpToMaxHp;
			if (obj4 == null)
			{
				hook_SetHpToMaxHp val4 = SetHpToMaxHp;
				<>O.<3>__SetHpToMaxHp = val4;
				obj4 = (object)val4;
			}
			Hp.SetHpToMaxHp += (hook_SetHpToMaxHp)obj4;
		}

		private static bool TakeDamage(orig_TakeDamage original, Hp self, float amount, TaggedObject damageComingFrom, bool causedByPlayer, bool invokeFeedbackEvents)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Identifier component = ((Component)self).GetComponent<Identifier>();
			if ((Object)(object)component == (Object)null || component.Type == IdentifierType.Invalid)
			{
				return original.Invoke(self, amount, damageComingFrom, causedByPlayer, invokeFeedbackEvents);
			}
			if (Plugin.Instance.Network.Server)
			{
				DamageFeedbackPacket basePacket = new DamageFeedbackPacket
				{
					Target = new IdentifierData(component),
					CausedByPlayer = causedByPlayer
				};
				Plugin.Instance.Network.Send(basePacket);
			}
			else if (!AllowHealthChangeOnClient)
			{
				return false;
			}
			return original.Invoke(self, amount, damageComingFrom, causedByPlayer, invokeFeedbackEvents);
		}

		private static void ScaleHp(orig_ScaleHp original, Hp self, float multiply)
		{
			Identifier component = ((Component)self).GetComponent<Identifier>();
			if ((Object)(object)component == (Object)null || component.Type == IdentifierType.Invalid)
			{
				original.Invoke(self, multiply);
			}
			else if (Plugin.Instance.Network.Server || AllowHealthChangeOnClient)
			{
				original.Invoke(self, multiply);
			}
		}

		private static void Heal(orig_Heal original, Hp self, float amount)
		{
			Identifier component = ((Component)self).GetComponent<Identifier>();
			if ((Object)(object)component == (Object)null || component.Type == IdentifierType.Invalid)
			{
				original.Invoke(self, amount);
			}
			else if (Plugin.Instance.Network.Server || AllowHealthChangeOnClient)
			{
				original.Invoke(self, amount);
			}
		}

		private static void SetHpToMaxHp(orig_SetHpToMaxHp original, Hp self)
		{
			Identifier component = ((Component)self).GetComponent<Identifier>();
			if ((Object)(object)component == (Object)null || component.Type == IdentifierType.Invalid)
			{
				original.Invoke(self);
			}
			else if (Plugin.Instance.Network.Server || AllowHealthChangeOnClient)
			{
				original.Invoke(self);
			}
		}
	}
	public static class InGameResignUIHelperPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Resign <0>__Resign;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			object obj = <>O.<0>__Resign;
			if (obj == null)
			{
				hook_Resign val = Resign;
				<>O.<0>__Resign = val;
				obj = (object)val;
			}
			InGameResignUIHelper.Resign += (hook_Resign)obj;
		}

		private static void Resign(orig_Resign original, InGameResignUIHelper self)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			ResignPacket basePacket = new ResignPacket();
			Plugin.Instance.Network.Send(basePacket, handleLocal: true);
		}
	}
	public class LevelBorderPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__Start;

			public static hook_Update <1>__Update;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			object obj = <>O.<0>__Start;
			if (obj == null)
			{
				hook_Start val = Start;
				<>O.<0>__Start = val;
				obj = (object)val;
			}
			LevelBorder.Start += (hook_Start)obj;
			object obj2 = <>O.<1>__Update;
			if (obj2 == null)
			{
				hook_Update val2 = Update;
				<>O.<1>__Update = val2;
				obj2 = (object)val2;
			}
			LevelBorder.Update += (hook_Update)obj2;
		}

		private static void Start(orig_Start original, LevelBorder self)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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)
			Traverse<Color> val = Traverse.Create((object)self).Field<Color>("defaultColor");
			Traverse<Color> val2 = Traverse.Create((object)self).Field<Color>("fadeOutColor");
			val.Value = ((ShapeRenderer)self.line).Color;
			Color value = val.Value;
			value.a = 0f;
			val2.Value = value;
			((ShapeRenderer)self.line).Color = val2.Value;
		}

		private static void Update(orig_Update original, LevelBorder self)
		{
			//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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			PlayerNetworkData playerNetworkData = Plugin.Instance.PlayerManager.LocalPlayer?.Data;
			if ((Object)(object)playerNetworkData == (Object)null)
			{
				return;
			}
			Vector3 position = ((Component)playerNetworkData).transform.position;
			Traverse<float> val = Traverse.Create((object)self).Field<float>("timer");
			Traverse<float> val2 = Traverse.Create((object)self).Field<float>("tickTime");
			Traverse<BoxCollider> val3 = Traverse.Create((object)self).Field<BoxCollider>("boxCol");
			Traverse<bool> val4 = Traverse.Create((object)self).Field<bool>("fadedIn");
			Traverse<float> val5 = Traverse.Create((object)self).Field<float>("fadeInDistance");
			Traverse<Coroutine> val6 = Traverse.Create((object)self).Field<Coroutine>("currentFade");
			Traverse val7 = Traverse.Create((object)self).Method("FadeIn", Array.Empty<object>());
			Traverse val8 = Traverse.Create((object)self).Method("FadeOut", Array.Empty<object>());
			val.Value += Time.deltaTime;
			if (!(val.Value >= val2.Value))
			{
				return;
			}
			val.Value = 0f;
			float num = Vector3.Distance(position, ((Collider)val3.Value).ClosestPoint(position));
			if (val4.Value)
			{
				if (num > val5.Value)
				{
					if (val6.Value == null)
					{
						IEnumerator value = val8.GetValue<IEnumerator>();
						val6.Value = ((MonoBehaviour)self).StartCoroutine(value);
					}
					val4.Value = false;
				}
			}
			else if (num <= val5.Value)
			{
				if (val6.Value == null)
				{
					IEnumerator value2 = val7.GetValue<IEnumerator>();
					val6.Value = ((MonoBehaviour)self).StartCoroutine(value2);
				}
				val4.Value = true;
			}
		}
	}
	public static class LevelSelectManagerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_MovePlayerToTheLevelYouCameFrom <0>__MovePlayerToTheLevelYouCameFrom;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			object obj = <>O.<0>__MovePlayerToTheLevelYouCameFrom;
			if (obj == null)
			{
				hook_MovePlayerToTheLevelYouCameFrom val = MovePlayerToTheLevelYouCameFrom;
				<>O.<0>__MovePlayerToTheLevelYouCameFrom = val;
				obj = (object)val;
			}
			LevelSelectManager.MovePlayerToTheLevelYouCameFrom += (hook_MovePlayerToTheLevelYouCameFrom)obj;
		}

		private static void MovePlayerToTheLevelYouCameFrom(orig_MovePlayerToTheLevelYouCameFrom original, LevelSelectManager self)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			SceneTransitionManager instance = SceneTransitionManager.instance;
			if (!Object.op_Implicit((Object)(object)instance) || instance.ComingFromGameplayScene == "")
			{
				return;
			}
			Traverse<LevelInteractor[]> val = Traverse.Create((object)self).Field<LevelInteractor[]>("levelInteractors");
			LevelInteractor[] value = val.Value;
			foreach (LevelInteractor val2 in value)
			{
				if (val2.levelInfo.sceneName != instance.ComingFromGameplayScene)
				{
					continue;
				}
				{
					foreach (PlayerNetworkData allPlayerDatum in Plugin.Instance.PlayerManager.GetAllPlayerData())
					{
						PlayerMovement component = ((Component)allPlayerDatum).GetComponent<PlayerMovement>();
						Vector3 position = ((Component)val2).transform.position + self.spawnOnLevelOffsetPositon;
						position = Helpers.GetSpawnLocation(position, allPlayerDatum.id);
						component.TeleportTo(position);
					}
					break;
				}
			}
		}
	}
	[HarmonyPatch]
	public static class LevelStartGatePatch
	{
		[HarmonyPatch(typeof(TransitionToSelectedLevelHelper), "TransitionToSelectedLevel")]
		[HarmonyPrefix]
		private static bool GateHelper()
		{
			return GateAllows();
		}

		[HarmonyPatch(typeof(LevelSelectUIFrameHelper), "TransitionToSelectedLevel")]
		[HarmonyPrefix]
		private static bool GateFrameHelper()
		{
			return GateAllows();
		}

		private static bool GateAllows()
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.Instance.Network.Online || !SceneTransitionManagerPatch.InLevelSelect)
			{
				return true;
			}
			UIFrameManager instance = UIFrameManager.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)LoadoutFrames.HelperFor(instance.ActiveFrame) == (Object)null)
			{
				return true;
			}
			foreach (PlayerManager.Player allPlayer in Plugin.Instance.PlayerManager.GetAllPlayers())
			{
				LoadoutState.WeaponPicks.TryGetValue(allPlayer.Id, out var value);
				if (value == Equipment.Invalid)
				{
					string friendPersonaName = SteamFriends.GetFriendPersonaName(allPlayer.SteamID);
					UIManager.CreateMessageDialog("Not so fast", "Waiting for " + friendPersonaName + " to pick a weapon.");
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(LocalGamestate), "OnVitalObjectKill")]
	public static class LocalGamestateDefeatPatch
	{
		[HarmonyPrefix]
		private static bool OnVitalObjectKill()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			ThronefallMP.Network.Network network = Plugin.Instance.Network;
			if (!network.Online)
			{
				return true;
			}
			if (network.Server)
			{
				if ((Object)(object)LocalGamestate.Instance != (Object)null && (int)LocalGamestate.Instance.CurrentState == 1)
				{
					network.Send(new ResignPacket());
				}
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(ManualAttack), "Tick")]
	internal static class ManualAttackPatch
	{
		private static void Prefix(ManualAttack __instance, out (bool restore, TaggedObject target, bool set) __state)
		{
			PlayerNetworkData componentInParent = ((Component)__instance).GetComponentInParent<PlayerNetworkData>();
			if ((Object)(object)componentInParent == (Object)null || componentInParent.IsLocal)
			{
				__state = (restore: false, target: null, set: false);
				return;
			}
			Traverse val = Traverse.Create((object)__instance);
			__state = (restore: true, target: val.Field<TaggedObject>("preferredTarget").Value, set: val.Field<bool>("preferredTargetPreviouslySet").Value);
		}

		private static void Postfix(ManualAttack __instance, (bool restore, TaggedObject target, bool set) __state)
		{
			if (__state.restore)
			{
				Traverse val = Traverse.Create((object)__instance);
				val.Field<TaggedObject>("preferredTarget").Value = __state.target;
				val.Field<bool>("preferredTargetPreviouslySet").Value = __state.set;
			}
		}
	}
	[HarmonyPatch(typeof(MinimapRenderer), "DrawPlayer")]
	internal static class MinimapRendererPatch
	{
		private static bool Prefix()
		{
			return (Object)(object)PlayerMovement.instance != (Object)null;
		}
	}
	public static class NightCallPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_UpdateFill <0>__UpdateFill;
		}

		private static bool _sentNightPacket;

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			object obj = <>O.<0>__UpdateFill;
			if (obj == null)
			{
				hook_UpdateFill val = UpdateFill;
				<>O.<0>__UpdateFill = val;
				obj = (object)val;
			}
			NightCall.UpdateFill += (hook_UpdateFill)obj;
		}

		private static void UpdateFill(orig_UpdateFill original, NightCall self)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: 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_016b: 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_0236: 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_020a: 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_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			HandleNightCallAudio(self);
			PlayerNetworkData playerNetworkData = Plugin.Instance.PlayerManager.LocalPlayer?.Data;
			if ((Object)(object)playerNetworkData == (Object)null)
			{
				return;
			}
			Traverse<bool> val = Traverse.Create((object)self).Field<bool>("active");
			Traverse<float> val2 = Traverse.Create((object)self).Field<float>("currentFill");
			Traverse<MPImage> val3 = Traverse.Create((object)self).Field<MPImage>("background");
			Traverse<Color> val4 = Traverse.Create((object)self).Field<Color>("defaultBackgroundColor");
			if (val.Value)
			{
				PlayerInteraction component = ((Component)playerNetworkData).GetComponent<PlayerInteraction>();
				((Transform)self.scaleParent).localScale = Vector3.one;
				if (playerNetworkData.SharedData.CallNightButton && component.IsFreeToCallNight)
				{
					val2.Value += Time.deltaTime * (1f / self.nightCallTime);
				}
				else
				{
					val2.Value -= Time.deltaTime * 2f * (1f / self.nightCallTime);
				}
				if (val2.Value < 1f)
				{
					_sentNightPacket = false;
				}
				else if (!_sentNightPacket)
				{
					_sentNightPacket = true;
					DayNightPacket basePacket = new DayNightPacket
					{
						Timestate = (Timestate)1
					};
					Plugin.Instance.Network.Send(basePacket, Plugin.Instance.Network.Server);
				}
				if (val2.Value > 0f)
				{
					((Component)self.nightCallCueText).gameObject.SetActive(true);
					((TMP_Text)self.nightCallTimeText).text = (self.nightCallTime * (1f - val2.Value)).ToString("F1") + "s";
					((TMP_Text)self.nightCallCueText).transform.localScale = Vector3.one * self.textCueScaleCurve.Evaluate(Mathf.InverseLerp(0f, 0.15f, val2.Value));
				}
				else
				{
					((Component)self.nightCallCueText).gameObject.SetActive(false);
					((TMP_Text)self.nightCallCueText).transform.localScale = Vector3.one;
				}
				Color value = val4.Value;
				value.a = Mathf.InverseLerp(0f, 0.4f, val2.Value);
				val4.Value = value;
				((Graphic)self.background).color = value;
				val2.Value = Mathf.Clamp01(val2.Value);
				((Image)self.targetGraphic).fillAmount = val2.Value;
			}
			else
			{
				_sentNightPacket = false;
				if (val2.Value > 0f)
				{
					val2.Value -= Time.deltaTime * 2f;
					Color value2 = val4.Value;
					value2.a = Mathf.InverseLerp(0f, 0.4f, val2.Value);
					val4.Value = value2;
					((Graphic)val3.Value).color = value2;
				}
			}
		}

		private static void HandleNightCallAudio(NightCall self)
		{
			Traverse<bool> val = Traverse.Create((object)self).Field<bool>("active");
			Traverse<float> val2 = Traverse.Create((object)self).Field<float>("nightCallTargetVolume");
			float num = 0f;
			if (val.Value)
			{
				foreach (PlayerNetworkData allPlayerDatum in Plugin.Instance.PlayerManager.GetAllPlayerData())
				{
					if (!allPlayerDatum.CallNightLast && allPlayerDatum.SharedData.CallNightButton)
					{
						self.nightCallAudio.Stop();
						self.nightCallAudio.PlayOneShot(ThronefallAudioManager.Instance.audioContent.NightCallStart, 0.45f);
					}
					allPlayerDatum.CallNightLast = allPlayerDatum.SharedData.CallNightButton;
					if (allPlayerDatum.SharedData.CallNightFill > 0f)
					{
						num = Mathf.Max(num, Mathf.Lerp(0f, val2.Value, Mathf.InverseLerp(0f, 0.3f, allPlayerDatum.SharedData.CallNightFill)));
					}
				}
			}
			self.nightCallAudio.volume = num;
		}

		public static void TriggerNightFall()
		{
			NightCall instance = NightCall.instance;
			instance.nightCallAudio.PlayOneShot(ThronefallAudioManager.Instance.audioContent.NightCallComplete, 0.8f);
			DayNightCycle.Instance.SwitchToNight();
			((MMFeedbacks)instance.fullFeedback).PlayFeedbacks();
			Traverse<bool> val = Traverse.Create((object)instance).Field<bool>("active");
			val.Value = false;
		}
	}
	[HarmonyPatch(typeof(OnDamageFeedbackHandler), "TakeDamage")]
	public static class OnDamageFeedbackHandlerPatch
	{
		[HarmonyPrefix]
		private static bool TakeDamage(OnDamageFeedbackHandler __instance, bool causedByPlayer)
		{
			if ((Object)(object)__instance.flasher == (Object)null)
			{
				return false;
			}
			if (causedByPlayer && (Object)(object)__instance.onDmgByPlayerFX == (Object)null)
			{
				float value = Traverse.Create((object)__instance).Field<float>("flashDuration").Value;
				__instance.flasher.TriggerFlash(true, value);
				return false;
			}
			return true;
		}
	}
	public static class PathFinderMovementEnemyPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_OriginalOnPathComplete <0>__OriginalOnPathComplete;

			public static hook_BackupOnPathComplete <1>__BackupOnPathComplete;

			public static hook_FindMoveToTarget <2>__FindMoveToTarget;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			object obj = <>O.<0>__OriginalOnPathComplete;
			if (obj == null)
			{
				hook_OriginalOnPathComplete val = OriginalOnPathComplete;
				<>O.<0>__OriginalOnPathComplete = val;
				obj = (object)val;
			}
			PathfindMovementEnemy.OriginalOnPathComplete += (hook_OriginalOnPathComplete)obj;
			object obj2 = <>O.<1>__BackupOnPathComplete;
			if (obj2 == null)
			{
				hook_BackupOnPathComplete val2 = BackupOnPathComplete;
				<>O.<1>__BackupOnPathComplete = val2;
				obj2 = (object)val2;
			}
			PathfindMovementEnemy.BackupOnPathComplete += (hook_BackupOnPathComplete)obj2;
			object obj3 = <>O.<2>__FindMoveToTarget;
			if (obj3 == null)
			{
				hook_FindMoveToTarget val3 = FindMoveToTarget;
				<>O.<2>__FindMoveToTarget = val3;
				obj3 = (object)val3;
			}
			PathfindMovementEnemy.FindMoveToTarget += (hook_FindMoveToTarget)obj3;
		}

		private static void OriginalOnPathComplete(orig_OriginalOnPathComplete original, PathfindMovementEnemy self, Path p)
		{
			if (Plugin.Instance.Network.Server)
			{
				original.Invoke(self, p);
			}
		}

		private static void BackupOnPathComplete(orig_BackupOnPathComplete original, PathfindMovementEnemy self, Path p)
		{
			if (Plugin.Instance.Network.Server)
			{
				original.Invoke(self, p);
			}
		}

		private static Vector3 FindMoveToTarget(orig_FindMoveToTarget original, PathfindMovementEnemy self)
		{
			//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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.Instance.Network.Server)
			{
				return original.Invoke(self);
			}
			return Traverse.Create((object)self).Field<Vector3>("seekToTargetPos").Value;
		}
	}
	public static class PathfindMovementPlayerunitPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_OriginalOnPathComplete <0>__OriginalOnPathComplete;

			public static hook_BackupOnPathComplete <1>__BackupOnPathComplete;

			public static hook_FindMoveToTarget <2>__FindMoveToTarget;

			public static hook_OnDawn_BeforeSunrise <3>__OnDawn_BeforeSunrise;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//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_007f: Expected O, but got Unknown
			object obj = <>O.<0>__OriginalOnPathComplete;
			if (obj == null)
			{
				hook_OriginalOnPathComplete val = OriginalOnPathComplete;
				<>O.<0>__OriginalOnPathComplete = val;
				obj = (object)val;
			}
			PathfindMovementPlayerunit.OriginalOnPathComplete += (hook_OriginalOnPathComplete)obj;
			object obj2 = <>O.<1>__BackupOnPathComplete;
			if (obj2 == null)
			{
				hook_BackupOnPathComplete val2 = BackupOnPathComplete;
				<>O.<1>__BackupOnPathComplete = val2;
				obj2 = (object)val2;
			}
			PathfindMovementPlayerunit.BackupOnPathComplete += (hook_BackupOnPathComplete)obj2;
			object obj3 = <>O.<2>__FindMoveToTarget;
			if (obj3 == null)
			{
				hook_FindMoveToTarget val3 = FindMoveToTarget;
				<>O.<2>__FindMoveToTarget = val3;
				obj3 = (object)val3;
			}
			PathfindMovementPlayerunit.FindMoveToTarget += (hook_FindMoveToTarget)obj3;
			object obj4 = <>O.<3>__OnDawn_BeforeSunrise;
			if (obj4 == null)
			{
				hook_OnDawn_BeforeSunrise val4 = OnDawn_BeforeSunrise;
				<>O.<3>__OnDawn_BeforeSunrise = val4;
				obj4 = (object)val4;
			}
			PathfindMovementPlayerunit.OnDawn_BeforeSunrise += (hook_OnDawn_BeforeSunrise)obj4;
		}

		private static void OriginalOnPathComplete(orig_OriginalOnPathComplete original, PathfindMovementPlayerunit self, Path p)
		{
			if (Plugin.Instance.Network.Server)
			{
				original.Invoke(self, p);
			}
		}

		private static void BackupOnPathComplete(orig_BackupOnPathComplete original, PathfindMovementPlayerunit self, Path p)
		{
			if (Plugin.Instance.Network.Server)
			{
				original.Invoke(self, p);
			}
		}

		private static Vector3 FindMoveToTarget(orig_FindMoveToTarget original, PathfindMovementPlayerunit self)
		{
			//IL_002b: 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_0030: 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)
			return Plugin.Instance.Network.Server ? original.Invoke(self) : Traverse.Create((object)self).Field<Vector3>("seekToTargetPos").Value;
		}

		private static void OnDawn_BeforeSunrise(orig_OnDawn_BeforeSunrise original, PathfindMovementPlayerunit self)
		{
			if (Plugin.Instance.Network.Server)
			{
				original.Invoke(self);
			}
		}
	}
	public static class PerkHpModifyerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__Start;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			object obj = <>O.<0>__Start;
			if (obj == null)
			{
				hook_Start val = Start;
				<>O.<0>__Start = val;
				obj = (object)val;
			}
			PerkHpModifyer.Start += (hook_Start)obj;
		}

		private static void Start(orig_Start original, PerkHpModifyer self)
		{
			HpPatch.AllowHealthChangeOnClient = true;
			original.Invoke(self);
			HpPatch.AllowHealthChangeOnClient = false;
		}
	}
	public static class PerkWeaponModifyerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__Start;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			object obj = <>O.<0>__Start;
			if (obj == null)
			{
				hook_Start val = Start;
				<>O.<0>__Start = val;
				obj = (object)val;
			}
			PerkWeaponModifyer.Start += (hook_Start)obj;
		}

		private static void Start(orig_Start original, PerkWeaponModifyer self)
		{
			Equipment equipment = Equip.Convert(self.requiredPerk);
			Equipment equipment2 = equipment;
			Equipment equipment3 = equipment2;
			if ((uint)(equipment3 - 2) <= 2u)
			{
				Plugin.Log.LogInfo((object)("Checking PerkWeaponModifyer in '" + Helpers.GetPath(((Component)self).transform) + "'"));
				Identifier componentInParent = ((Component)self).GetComponentInParent<Identifier>();
				if (!((Object)(object)componentInParent == (Object)null) && componentInParent.Type == IdentifierType.Player)
				{
					Equipment weapon = Plugin.Instance.PlayerManager.Get((int)componentInParent.Id).Weapon;
					if (weapon == equipment)
					{
						self.autoAttack.weapon = self.weaponToInsert;
					}
				}
				Object.Destroy((Object)(object)self);
			}
			else
			{
				original.Invoke(self);
			}
		}
	}
	public static class PlayerAttackPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Update <0>__Update;
		}

		private static TaggedObject _lastPreferredTarget;

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			object obj = <>O.<0>__Update;
			if (obj == null)
			{
				hook_Update val = Update;
				<>O.<0>__Update = val;
				obj = (object)val;
			}
			PlayerAttack.Update += (hook_Update)obj;
		}

		private static void Update(orig_Update orig, PlayerAttack self)
		{
			Traverse<ManualAttack> val = Traverse.Create((object)self).Field<ManualAttack>("attack");
			if ((Object)(object)val.Value != (Object)null)
			{
				val.Value.Tick();
				PlayerNetworkData component = ((Component)self).GetComponent<PlayerNetworkData>();
				if ((Object)(object)component != (Object)null && component.IsLocal)
				{
					self.ui.SetCurrentCooldownPercentage(val.Value.CooldownPercentage);
					BroadcastTargetLock(val.Value, component);
				}
			}
		}

		private static void BroadcastTargetLock(ManualAttack attack, PlayerNetworkData data)
		{
			//IL_0095: 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)
			TaggedObject value = Traverse.Create((object)attack).Field<TaggedObject>("preferredTarget").Value;
			if (!((Object)(object)value == (Object)(object)_lastPreferredTarget))
			{
				_lastPreferredTarget = value;
				if (Plugin.Instance.Network.Online)
				{
					Identifier identifier = (((Object)(object)value == (Object)null) ? null : ((Component)value).GetComponent<Identifier>());
					Plugin.Instance.Network.Send(new LockTargetPacket
					{
						PlayerId = data.id,
						Target = (((Object)(object)identifier == (Object)null) ? IdentifierData.Invalid : new IdentifierData(identifier))
					});
				}
			}
		}
	}
	public static class PlayerInteractionPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__Awake;

			public static hook_FetchCoins <1>__FetchCoins;

			public static hook_FetchInteractors <2>__FetchInteractors;

			public static hook_RunInteraction <3>__RunInteraction;

			public static hook_AddCoin <4>__AddCoin;

			public static hook_SpendCoins <5>__SpendCoins;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//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_007f: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00b6: 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_00c1: Expected O, but got Unknown
			object obj = <>O.<0>__Awake;
			if (obj == null)
			{
				hook_Awake val = Awake;
				<>O.<0>__Awake = val;
				obj = (object)val;
			}
			PlayerInteraction.Awake += (hook_Awake)obj;
			object obj2 = <>O.<1>__FetchCoins;
			if (obj2 == null)
			{
				hook_FetchCoins val2 = FetchCoins;
				<>O.<1>__FetchCoins = val2;
				obj2 = (object)val2;
			}
			PlayerInteraction.FetchCoins += (hook_FetchCoins)obj2;
			object obj3 = <>O.<2>__FetchInteractors;
			if (obj3 == null)
			{
				hook_FetchInteractors val3 = FetchInteractors;
				<>O.<2>__FetchInteractors = val3;
				obj3 = (object)val3;
			}
			PlayerInteraction.FetchInteractors += (hook_FetchInteractors)obj3;
			object obj4 = <>O.<3>__RunInteraction;
			if (obj4 == null)
			{
				hook_RunInteraction val4 = RunInteraction;
				<>O.<3>__RunInteraction = val4;
				obj4 = (object)val4;
			}
			PlayerInteraction.RunInteraction += (hook_RunInteraction)obj4;
			object obj5 = <>O.<4>__AddCoin;
			if (obj5 == null)
			{
				hook_AddCoin val5 = AddCoin;
				<>O.<4>__AddCoin = val5;
				obj5 = (object)val5;
			}
			PlayerInteraction.AddCoin += (hook_AddCoin)obj5;
			object obj6 = <>O.<5>__SpendCoins;
			if (obj6 == null)
			{
				hook_SpendCoins val6 = SpendCoins;
				<>O.<5>__SpendCoins = val6;
				obj6 = (object)val6;
			}
			PlayerInteraction.SpendCoins += (hook_SpendCoins)obj6;
		}

		private static void Awake(orig_Awake original, PlayerInteraction self)
		{
			PlayerNetworkData component = ((Component)self).GetComponent<PlayerNetworkData>();
			if ((Object)(object)component == (Object)null || component.IsLocal)
			{
				original.Invoke(self);
			}
		}

		private static void FetchCoins(orig_FetchCoins original, PlayerInteraction self)
		{
			//IL_0007: 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_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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00d5: 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_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)
			Collider[] array = Physics.OverlapSphere(((Component)self).transform.position, self.coinMagnetRadius, LayerMask.op_Implicit(self.coinLayer));
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				Coin component = ((Component)val).GetComponent<Coin>();
				if ((Object)(object)component != (Object)null && component.IsFree)
				{
					Traverse<PlayerInteraction> val2 = Traverse.Create((object)component).Field<PlayerInteraction>("target");
					if ((Object)(object)val2.Value == (Object)null || (Object)(object)val2.Value == (Object)(object)self)
					{
						component.SetTarget(self);
						continue;
					}
					Vector3 position = ((Component)component).transform.position;
					Vector3 val3 = ((Component)val2.Value).transform.position - position;
					float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
					val3 = ((Component)self).transform.position - position;
					float sqrMagnitude2 = ((Vector3)(ref val3)).sqrMagnitude;
					component.SetTarget((sqrMagnitude2 < sqrMagnitude) ? self : val2.Value);
				}
			}
		}

		private static void FetchInteractors(orig_FetchInteractors original, PlayerInteraction self)
		{
			PlayerNetworkData component = ((Component)self).GetComponent<PlayerNetworkData>();
			if (!((Object)(object)component != (Object)null) || component.IsLocal)
			{
				original.Invoke(self);
				TreasuryUIPatch.OverrideFocus = self.FocussedInteractor is BuildingInteractor;
			}
		}

		private static void RunInteraction(orig_RunInteraction original, PlayerInteraction self)
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			PlayerNetworkData component = ((Component)self).GetComponent<PlayerNetworkData>();
			if ((Object)(object)component == (Object)null || !component.IsLocal || LocalGamestate.Instance.PlayerFrozen)
			{
				return;
			}
			Traverse<Player> val = Traverse.Create((object)self).Field<Player>("input");
			Traverse<InteractorBase> val2 = Traverse.Create((object)self).Field<InteractorBase>("focussedInteractor");
			if (val.Value.GetButtonDown("Interact"))
			{
				if ((Object)(object)val2.Value != (Object)null)
				{
					val2.Value.InteractionBegin(self);
				}
				else if ((Object)(object)self.ManualAttack != (Object)null)
				{
					ManualAttackPacket basePacket = new ManualAttackPacket
					{
						Player = component.id
					};
					Plugin.Instance.Network.Send(basePacket, handleLocal: true);
				}
			}
			if ((Object)(object)val2.Value != (Object)null)
			{
				if (val.Value.GetButton("Interact"))
				{
					val2.Value.InteractionHold(self);
				}
				if (val.Value.GetButtonUp("Interact"))
				{
					val2.Value.InteractionEnd(self);
				}
			}
			BuildingInteractor.displayAllBuildPreviews = val.Value.GetButton("Preview Build Options");
		}

		private static void AddCoin(orig_AddCoin original, PlayerInteraction self, int amount)
		{
			if (Plugin.Instance.Network.Server)
			{
				GlobalData.Internal.NetWorth += amount;
				GlobalData.Balance += amount;
			}
		}

		private static void SpendCoins(orig_SpendCoins orig, PlayerInteraction self, int amount)
		{
			GlobalData.Balance -= amount;
		}
	}
	internal static class PlayerMovementPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__Awake;

			public static hook_Start <1>__Start;

			public static hook_Update <2>__Update;

			public static hook_TeleportTo <3>__TeleportTo;

			public static hook_Start <4>__Start;
		}

		private static readonly int Moving = Animator.StringToHash("Moving");

		private static readonly int Sprinting = Animator.StringToHash("Sprinting");

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//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_007f: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			object obj = <>O.<0>__Awake;
			if (obj == null)
			{
				hook_Awake val = Awake;
				<>O.<0>__Awake = val;
				obj = (object)val;
			}
			PlayerMovement.Awake += (hook_Awake)obj;
			object obj2 = <>O.<1>__Start;
			if (obj2 == null)
			{
				hook_Start val2 = Start;
				<>O.<1>__Start = val2;
				obj2 = (object)val2;
			}
			PlayerMovement.Start += (hook_Start)obj2;
			object obj3 = <>O.<2>__Update;
			if (obj3 == null)
			{
				hook_Update val3 = Update;
				<>O.<2>__Update = val3;
				obj3 = (object)val3;
			}
			PlayerMovement.Update += (hook_Update)obj3;
			object obj4 = <>O.<3>__TeleportTo;
			if (obj4 == null)
			{
				hook_TeleportTo val4 = TeleportTo;
				<>O.<3>__TeleportTo = val4;
				obj4 = (object)val4;
			}
			PlayerMovement.TeleportTo += (hook_TeleportTo)obj4;
			object obj5 = <>O.<4>__Start;
			if (obj5 == null)
			{
				hook_Start val5 = Start;
				<>O.<4>__Start = val5;
				obj5 = (object)val5;
			}
			CameraRig.Start += (hook_Start)obj5;
		}

		private static void Start(orig_Start original, CameraRig self)
		{
			Traverse val = Traverse.Create((object)self);
			val.Field<Transform>("currentTarget").Value = val.Field<Transform>("cameraTarget").Value;
			val.Field<Player>("input").Value = ReInput.players.GetPlayer(0);
			float[] value = val.Field<float[]>("zoomLevels").Value;
			if (value != null && value.Length != 0)
			{
				val.Field<float>("targetOrthSize").Value = value[0];
			}
		}

		private static void Awake(orig_Awake original, PlayerMovement self)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((Component)self).GetComponent<PlayerNetworkData>() == (Object)null)
			{
				CameraRig componentInChildren = ((Component)self).GetComponentInChildren<CameraRig>();
				Traverse.Create((object)componentInChildren).Field<Quaternion>("startRotation").Value = ((Component)componentInChildren).transform.rotation;
				Traverse.Create((object)componentInChildren).Field<Transform>("cameraTarget").Value = ((Component)componentInChildren).transform.parent;
				((Component)componentInChildren).transform.SetParent((Transform)null);
				Plugin.Instance.PlayerManager.SetPrefab(((Component)self).gameObject);
				((Behaviour)self).enabled = false;
				Object.Destroy((Object)(object)((Component)self).gameObject);
			}
		}

		private static void Start(orig_Start original, PlayerMovement self)
		{
			if (!((Object)(object)((Component)self).gameObject.GetComponent<PlayerNetworkData>() == (Object)null))
			{
				original.Invoke(self);
			}
		}

		private static void Update(orig_Update original, PlayerMovement self)
		{
			//IL_019b: 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_01a5: 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_01ae: 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_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: 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_01eb: 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_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: 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_020e: 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_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: 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_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Invalid comparison between Unknown and I4
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: 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)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: 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_0446: 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_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_049e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0537: Unknown result type (might be due to invalid IL or missing references)
			//IL_053c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0548: Unknown result type (might be due to invalid IL or missing references)
			//IL_054d: 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_056b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0570: Unknown result type (might be due to invalid IL or missing references)
			//IL_058e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05af: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d2: 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)
			PlayerNetworkData component = ((Component)self).GetComponent<PlayerNetworkData>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			if (component.IsLocal && (Object)(object)PlayerMovement.instance != (Object)(object)self)
			{
				PlayerMovement.instance = self;
			}
			Hp value = Traverse.Create((object)self).Field<Hp>("hp").Value;
			RVOController value2 = Traverse.Create((object)self).Field<RVOController>("rvoController").Value;
			bool value3 = Traverse.Create((object)self).Field<bool>("heavyArmorEquipped").Value;
			bool value4 = Traverse.Create((object)self).Field<bool>("racingHorseEquipped").Value;
			Traverse<Vector3> val = Traverse.Create((object)self).Field<Vector3>("velocity");
			Traverse<float> val2 = Traverse.Create((object)self).Field<float>("yVelocity");
			Traverse<Transform> val3 = Traverse.Create((object)self).Field<Transform>("viewTransform");
			Traverse<bool> val4 = Traverse.Create((object)self).Field<bool>("sprintingToggledOn");
			Traverse<bool> val5 = Traverse.Create((object)self).Field<bool>("sprinting");
			Traverse<bool> val6 = Traverse.Create((object)self).Field<bool>("moving");
			Traverse<float> val7 = Traverse.Create((object)self).Field<float>("slowedFor");
			Traverse<Quaternion> val8 = Traverse.Create((object)self).Field<Quaternion>("desiredMeshRotation");
			Traverse<CharacterController> val9 = Traverse.Create((object)self).Field<CharacterController>("controller");
			if ((Object)(object)val3.Value == (Object)null)
			{
				return;
			}
			Vector2 zero = default(Vector2);
			((Vector2)(ref zero))..ctor(component.SharedData.MoveVertical, component.SharedData.MoveHorizontal);
			if (LocalGamestate.Instance.PlayerFrozen && component.IsLocal)
			{
				zero = Vector2.zero;
			}
			Vector3 val10 = Vector3.ProjectOnPlane(val3.Value.forward, Vector3.up);
			Vector3 normalized = ((Vector3)(ref val10)).normalized;
			val10 = Vector3.ProjectOnPlane(val3.Value.right, Vector3.up);
			Vector3 normalized2 = ((Vector3)(ref val10)).normalized;
			val.Value = Vector3.zero;
			val.Value += normalized * zero.x;
			val.Value += normalized2 * zero.y;
			val.Value = Vector3.ClampMagnitude(val.Value, 1f);
			bool flag = component.SharedData.SprintToggleButton && !component.PlayerMovementSprintLast;
			component.PlayerMovementSprintLast = component.SharedData.SprintToggleButton;
			if (flag)
			{
				val4.Value = !val4.Value;
			}
			if (val4.Value && component.SharedData.SprintButton)
			{
				val4.Value = false;
			}
			val7.Value -= Time.deltaTime;
			if (Plugin.Instance.Network.Server || component.IsLocal)
			{
				component.SharedData.Slowed = val7.Value > 0f;
			}
			val5.Value = (component.SharedData.SprintButton || val4.Value) && value.HpPercentage >= 1f;
			val.Value *= (val5.Value ? self.sprintSpeed : self.speed);
			val.Value *= (component.SharedData.Slowed ? 0.33f : 1f);
			if (value3 && (int)DayNightCycle.Instance.CurrentTimestate == 1)
			{
				val.Value *= PerkManager.instance.heavyArmor_SpeedMultiplyer;
			}
			if (value4)
			{
				val.Value *= PerkManager.instance.racingHorse_SpeedMultiplyer;
			}
			if ((Object)(object)value2 != (Object)null && ((Behaviour)value2).enabled)
			{
				value2.velocity = val.Value;
			}
			val10 = val.Value;
			val6.Value = ((Vector3)(ref val10)).sqrMagnitude > 0.1f;
			if (val6.Value)
			{
				val10 = val.Value;
				val8.Value = Quaternion.LookRotation(((Vector3)(ref val10)).normalized, Vector3.up);
			}
			if (val8.Value != self.meshParent.rotation)
			{
				self.meshParent.rotation = Quaternion.RotateTowards(self.meshParent.rotation, val8.Value, self.maxMeshRotationSpeed * Time.deltaTime);
			}
			self.meshAnimator.SetBool(Moving, val6.Value);
			self.meshAnimator.SetBool(Sprinting, val5.Value);
			if (((Collider)val9.Value).enabled)
			{
				if (val9.Value.isGrounded)
				{
					val2.Value = 0f;
				}
				else
				{
					val2.Value += -9.81f * Time.deltaTime;
				}
				val.Value += Vector3.up * val2.Value;
				val9.Value.Move(val.Value * Time.deltaTime);
				Traverse<float> val11 = Traverse.Create((object)self).Field<float>("yFallThroughMapDetection");
				if (((Component)self).transform.position.y < val11.Value)
				{
					val.Value = Vector3.zero;
					val2.Value = 0f;
					self.TeleportTo(Helpers.GetSpawnLocation(Plugin.Instance.PlayerManager.SpawnLocation, component.Player.SpawnID));
				}
			}
		}

		private static void TeleportTo(orig_TeleportTo original, PlayerMovement self, Vector3 position)
		{
			//IL_0069: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)self == (Object)null)
			{
				return;
			}
			PlayerNetworkData component = ((Component)self).GetComponent<PlayerNetworkData>();
			if (!((Object)(object)component == (Object)null))
			{
				if (component.IsLocal)
				{
					TeleportPlayerPacket basePacket = new TeleportPlayerPacket
					{
						PlayerId = component.id,
						Position = position
					};
					Plugin.Instance.Network.Send(basePacket);
				}
				original.Invoke(self, position);
			}
		}
	}
	public static class PlayerSceptPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__Start;

			public static hook_Update <1>__Update;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			object obj = <>O.<0>__Start;
			if (obj == null)
			{
				hook_Start val = Start;
				<>O.<0>__Start = val;
				obj = (object)val;
			}
			PlayerScept.Start += (hook_Start)obj;
			object obj2 = <>O.<1>__Update;
			if (obj2 == null)
			{
				hook_Update val2 = Update;
				<>O.<1>__Update = val2;
				obj2 = (object)val2;
			}
			PlayerScept.Update += (hook_Update)obj2;
		}

		private static void Start(orig_Start original, PlayerScept self)
		{
			original.Invoke(self);
			Transform transform = ((Component)self).transform;
			self.loadoutParent = ((Component)transform.Find("Horse_LOD1/Rig/root/body/Humanoid Model Base/Civil Loadout")).gameObject;
		}

		private static void Update(orig_Update original, PlayerScept self)
		{
			PlayerNetworkData component = ((Component)((Component)self).transform.parent).GetComponent<PlayerNetworkData>();
			if (!((Object)(object)component == (Object)null))
			{
				if (component.SharedData.InteractButton && !component.PlayerScepterInteractLast)
				{
					((MonoBehaviour)self).StopAllCoroutines();
					((MonoBehaviour)self).StartCoroutine(Traverse.Create((object)self).Method("AnimationIn", Array.Empty<object>()).GetValue<IEnumerator>());
				}
				if (!component.SharedData.InteractButton && component.PlayerScepterInteractLast)
				{
					((MonoBehaviour)self).StopAllCoroutines();
					((MonoBehaviour)self).StartCoroutine(Traverse.Create((object)self).Method("AnimationOut", Array.Empty<object>()).GetValue<IEnumerator>());
				}
				component.PlayerScepterInteractLast = component.SharedData.InteractButton;
			}
		}
	}
	[HarmonyPatch(typeof(PushPlayer2D), "Update")]
	public static class PushPlayer2DPatch
	{
		[HarmonyPrefix]
		private static bool Update(PushPlayer2D __instance)
		{
			Transform value = Traverse.Create((object)__instance).Field<Transform>("ptrans").Value;
			PlayerMovement value2 = Traverse.Create((object)__instance).Field<PlayerMovement>("pm").Value;
			return (Object)(object)value != (Object)null && (Object)(object)value2 != (Object)null;
		}
	}
	public static class RevivePanelPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Update <0>__Update;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			object obj = <>O.<0>__Update;
			if (obj == null)
			{
				hook_Update val = Update;
				<>O.<0>__Update = val;
				obj = (object)val;
			}
			RevivePanel.Update += (hook_Update)obj;
		}

		private static void Update(orig_Update original, RevivePanel self)
		{
			PlayerNetworkData playerNetworkData = Plugin.Instance.PlayerManager.LocalPlayer?.Data;
			if ((Object)(object)playerNetworkData != (Object)null)
			{
				AutoRevive val = (self.playerReviveComponent = ((Component)playerNetworkData).GetComponent<AutoRevive>());
				Hp component = ((Component)playerNetworkData).GetComponent<Hp>();
				if ((Object)(object)val != (Object)null && (Object)(object)component != (Object)null && !component.KnockedOut)
				{
					Traverse.Create((object)val).Field<float>("hasBeenKnockedOutFor").Value = 0f;
				}
			}
			original.Invoke(self);
		}
	}
	public static class SceneTransitionManagerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_TransitionToScene <0>__TransitionToScene;

			public static hook_SceneTransitionAnimation <1>__SceneTransitionAnimation;

			public static UnityAction<Scene, LoadSceneMode> <2>__OnSceneChanged;
		}

		public static string CurrentScene;

		public static bool InLevelSelect;

		private static bool _transitionHookEnabled = true;

		private static (string to, string from)? _queuedTransition;

		private static GameObject _networkRoot;

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			object obj = <>O.<0>__TransitionToScene;
			if (obj == null)
			{
				hook_TransitionToScene val = TransitionToScene;
				<>O.<0>__TransitionToScene = val;
				obj = (object)val;
			}
			SceneTransitionManager.TransitionToScene += (hook_TransitionToScene)obj;
			object obj2 = <>O.<1>__SceneTransitionAnimation;
			if (obj2 == null)
			{
				hook_SceneTransitionAnimation val2 = SceneTransitionAnimation;
				<>O.<1>__SceneTransitionAnimation = val2;
				obj2 = (object)val2;
			}
			SceneTransitionManager.SceneTransitionAnimation += (hook_SceneTransitionAnimation)obj2;
			SceneManager.sceneLoaded += OnSceneChanged;
		}

		public static void Transition(string to, string from)
		{
			if (SceneTransitionManager.instance.SceneTransitionIsRunning)
			{
				_queuedTransition = (to, from);
				return;
			}
			Traverse<string> val = Traverse.Create((object)SceneTransitionManager.instance).Field<string>("comingFromGameplayScene");
			val.Value = from;
			_transitionHookEnabled = false;
			SceneTransitionManager.instance.TransitionFromNullToLevel(to);
			_transitionHookEnabled = true;
		}

		private static IEnumerator SceneTransitionAnimation(orig_SceneTransitionAnimation original, SceneTransitionManager self, string scene)
		{
			IEnumerator result = original.Invoke(self, scene);
			if (SceneTransitionManager.instance.SceneTransitionIsRunning || !_queuedTransition.HasValue)
			{
				return result;
			}
			Transition(_queuedTransition.Value.to, _queuedTransition.Value.from);
			_queuedTransition = null;
			return result;
		}

		private static void TransitionToScene(orig_TransitionToScene original, SceneTransitionManager self, string scene)
		{
			//IL_00f0: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			if (_transitionHookEnabled && scene != "_StartMenu" && Plugin.Instance.Network.Online)
			{
				RequestLevelPacket requestLevelPacket = new RequestLevelPacket
				{
					To = scene,
					From = CurrentScene,
					OverwriteSave = MatchSaveLoadHandler.OverwriteCurrentSave
				};
				foreach (Equippable item in PerkManager.instance.CurrentlyEquipped)
				{
					requestLevelPacket.Perks.Add(Equip.Convert(((Object)item).name));
				}
				if (Plugin.Instance.Network.Server)
				{
					SteamNetworkingIdentity sender = default(SteamNetworkingIdentity);
					((SteamNetworkingIdentity)(ref sender)).SetSteamID(Plugin.Instance.Network.Owner);
					PacketHandler.HandlePacket(sender, requestLevelPacket);
				}
				else
				{
					Plugin.Instance.Network.Send(requestLevelPacket);
				}
				UIFrameManager.instance.CloseAllFrames();
				return;
			}
			CurrentScene = scene;
			InLevelSelect = self.levelSelectScene == scene;
			Plugin.Log.LogInfo((object)("Transitioning '" + scene + "'"));
			foreach (PlayerNetworkData allPlayerDatum in Plugin.Instance.PlayerManager.GetAllPlayerData())
			{
				if ((Object)(object)allPlayerDatum == (Object)null)
				{
					continue;
				}
				if ((Object)(object)TagManager.instance != (Object)null)
				{
					List<TaggedObject> value = Traverse.Create((object)TagManager.instance).Field<List<TaggedObject>>("bufferedPlayers").Value;
					TaggedObject[] componentsInChildren = ((Component)allPlayerDatum).GetComponentsInChildren<TaggedObject>(true);
					foreach (TaggedObject val in componentsInChildren)
					{
						TagManager.instance.RemoveTaggedObject(val);
						value?.Remove(val);
					}
				}
				Object.Destroy((Object)(object)((Component)allPlayerDatum).gameObject);
			}
			original.Invoke(self, scene);
		}

		private static void OnSceneChanged(Scene scene, LoadSceneMode mode)
		{
			if (!InLevelSelect && (Object)(object)_networkRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_networkRoot);
			}
		}

		private static void InitializeLevelSelectObjects()
		{
			//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)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_005f: 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_00f6: 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_01b9: 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_01d4: 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_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_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: 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_023f: 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_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Expected O, but got Unknown
			//IL_0269: 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_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: 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_0337: Expected O, but got Unknown
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: 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_0369: 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_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: 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_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Expected O, but got Unknown
			GameObject val = new GameObject("Network");
			val.transform.position = new Vector3(26.3f, 0f, 19f);
			_networkRoot = val;
			GameObject val2 = Object.Instantiate<GameObject>(GameObject.Find("Levels/Neuland/Unlocked Level"), _networkRoot.transform);
			val2.transform.localPosition = new Vector3(-1.2999992f, 0.05f, -2.6000004f);
			GameObject val3 = Object.Instantiate<GameObject>(GameObject.Find("Levels/Neuland/Quest Counter"), _networkRoot.transform);
			val3.transform.localPosition = new Vector3(-1.2999992f, 11.2f, -2.6000004f);
			Object.Destroy((Object)(object)((Component)val3.transform.Find("Quests Canvas/Focus Panel")).gameObject);
			Object.Destroy((Object)(object)((Component)val3.transform.Find("Quests Canvas/Background")).gameObject);
			GameObject gameObject = ((Component)val3.transform.Find("Quests Canvas/Cant be Played Panel")).gameObject;
			gameObject.transform.localPosition = Vector3.zero;
			((TMP_Text)gameObject.GetComponentInChildren<TextMeshProUGUI>()).text = "Multiplayer";
			gameObject.SetActive(false);
			MpFlagInteractor mpFlagInteractor = val2.AddComponent<MpFlagInteractor>();
			mpFlagInteractor.Indicator = gameObject;
			mpFlagInteractor.InteractionDistance = 3.5f;
			GameObject val4 = Object.Instantiate<GameObject>(GameObject.Find("Terrain/LevelOutlines/Pathline"), _networkRoot.transform);
			val4.transform.localPosition = new Vector3(0f, 0.05f, 0f);
			while (val4.transform.childCount > 0)
			{
				Object.DestroyImmediate((Object)(object)((Component)val4.transform.GetChild(0)).gameObject);
			}
			Vector3[] array = (Vector3[])(object)new Vector3[5]
			{
				new Vector3(-11.799999f, 0f, 3.7999992f),
				new Vector3(-3.6999989f, 0f, -13f),
				new Vector3(4.4000015f, 0f, -8.9f),
				new Vector3(9.040001f, 0f, 6.1000004f),
				new Vector3(1.9000015f, 0f, 12.200001f)
			};
			Vector3[] array2 = array;
			foreach (Vector3 localPosition in array2)
			{
				GameObject val5 = new GameObject();
				val5.transform.parent = val4.transform;
				val5.transform.localPosition = localPosition;
				val5.transform.localScale = new Vector3(0.2f, 0.4f, 0.4f);
			}
			PathMesher component = val4.GetComponent<PathMesher>();
			component.UpdateMesh();
			GameObject val6 = Object.Instantiate<GameObject>(GameObject.Find("Terrain/Planes/Neuland"), _networkRoot.transform);
			val6.transform.localPosition = new Vector3(0f, 0f, 0f);
			val6.transform.localScale = new Vector3(1f, 1f, 1f);
			val6.transform.rotation = Quaternion.Euler(0f, 0f, 0f);
			Mesh val7 = new Mesh();
			((Object)val7).name = "Network Land";
			val7.vertices = array;
			val7.normals = (Vector3[])(object)new Vector3[5]
			{
				Vector3.up,
				Vector3.up,
				Vector3.up,
				Vector3.up,
				Vector3.up
			};
			val7.triangles = new int[9] { 0, 2, 1, 0, 3, 2, 0, 4, 3 };
			Mesh mesh = val7;
			MeshFilter component2 = val6.GetComponent<MeshFilter>();
			component2.mesh = mesh;
			MeshRenderer component3 = val6.GetComponent<MeshRenderer>();
			((Renderer)component3).material = new Material(((Renderer)component3).material)
			{
				color = new Color(0.4f, 0.3f, 0.15f)
			};
		}
	}
	[HarmonyPatch(typeof(Spawn), "Update")]
	internal static class SpawnPatch
	{
		private static readonly HashSet<Spawn> WarnedUnknownSpawns = new HashSet<Spawn>();

		private static bool Prefix(Spawn __instance, float difficultyMulti)
		{
			ThronefallMP.Network.Network network = Plugin.Instance.Network;
			if (!network.Online)
			{
				return true;
			}
			if ((Object)(object)__instance.enemyPrefab == (Object)null || (Object)(object)__instance.enemyPrefab.GetComponentInChildren<TaggedObject>() == (Object)null)
			{
				return true;
			}
			int num = BossSpawnRegistry.GetRef(__instance);
			if (num < 0)
			{
				if (WarnedUnknownSpawns.Add(__instance))
				{
					Plugin.Log.LogWarningFiltered("SpawnPatch", "Unregistered Spawn of '" + ((Object)__instance.enemyPrefab).name + "', spawning unsynced");
				}
				return true;
			}
			if (network.Server)
			{
				UpdateOnHost(__instance, (ushort)num, difficultyMulti);
			}
			return false;
		}

		private static void UpdateOnHost(Spawn self, ushort spawnRef, float difficultyMulti)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			if (Traverse.Create((object)self).Field<bool>("finished").Value)
			{
				return;
			}
			Traverse<float> val = Traverse.Create((object)self).Field<float>("waitBeforeNextSpawn");
			val.Value -= Time.deltaTime;
			if (!(val.Value > 0f))
			{
				val.Value = self.interval;
				Vector3 position = EnemySpawnerPatch.RollSpawnPosition(self);
				int coins = 0;
				Traverse<int> val2 = Traverse.Create((object)self).Field<int>("spawnedUnits");
				Traverse<int[]> val3 = Traverse.Create((object)self).Field<int[]>("goldCoinsPerEnemy");
				if (val3.Value.Length > val2.Value)
				{
					coins = val3.Value[val2.Value];
				}
				BossSpawnPacket basePacket = new BossSpawnPacket
				{
					SpawnRef = spawnRef,
					Id = EnemySpawnerPatch.AllocateEnemyId(),
					Position = position,
					Coins = coins,
					Elite = self.eliteEnemies,
					DifficultyMulti = difficultyMulti
				};
				Plugin.Instance.Network.Send(basePacket, handleLocal: true);
			}
		}
	}
	public static class SteamManagerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_UploadHighscore <0>__UploadHighscore;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			object obj = <>O.<0>__UploadHighscore;
			if (obj == null)
			{
				hook_UploadHighscore val = UploadHighscore;
				<>O.<0>__UploadHighscore = val;
				obj = (object)val;
			}
			SteamManager.UploadHighscore += (hook_UploadHighscore)obj;
		}

		private static void UploadHighscore(orig_UploadHighscore orig, SteamManager self, int _score, string _leaderboardname)
		{
		}
	}
	public class TreasuryUIPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__Start;

			public static hook_Update <1>__Update;
		}

		public static bool OverrideFocus;

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			object obj = <>O.<0>__Start;
			if (obj == null)
			{
				hook_Start val = Start;
				<>O.<0>__Start = val;
				obj = (object)val;
			}
			TreasuryUI.Start += (hook_Start)obj;
			object obj2 = <>O.<1>__Update;
			if (obj2 == null)
			{
				hook_Update val2 = Update;
				<>O.<1>__Update = val2;
				obj2 = (object)val2;
			}
			TreasuryUI.Update += (hook_Update)obj2;
		}

		private static void Start(orig_Start original, TreasuryUI self)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogInfo((object)"Registering Treasury UI");
			DayNightCycle.Instance.RegisterDaytimeSensitiveObject((IDaytimeSensitive)(object)self);
			Traverse<AnimationState> val = Traverse.Create((object)self).Field<AnimationState>("currentState");
			Traverse.Create((object)self).Field<Transform>("scaleTarget").Value = UIFrameManager.instance.TreasureChest.scaleTarget;
			Traverse.Create((object)self).Field<TextMeshProUGUI>("displayText").Value = UIFrameManager.instance.TreasureChest.balanceNumber;
			Traverse.Create((object)self).Method("SetState", new object[1] { val.Value }).GetValue();
		}

		private static void Update(orig_Update original, TreasuryUI self)
		{
			Traverse<bool> val = Traverse.Create((object)self).Field<bool>("overrideActivation");
			Traverse<float> val2 = Traverse.Create((object)self).Field<float>("activationCounter");
			Traverse<float> val3 = Traverse.Create((object)self).Field<float>("activationLifetime");
			Traverse<TextMeshProUGUI> val4 = Traverse.Create((object)self).Field<TextMeshProUGUI>("displayText");
			if (!OverrideFocus && val.Value)
			{
				val2.Value = val3.Value;
			}
			val.Value = OverrideFocus;
			Traverse<PlayerInteraction> val5 = Traverse.Create((object)self).Field<PlayerInteraction>("targetPlayer");
			if ((Object)(object)val5.Value == (Object)null)
			{
				PlayerNetworkData playerNetworkData = Plugin.Instance.PlayerManager.LocalPlayer?.Data;
				if ((Object)(object)playerNetworkData != (Object)null)
				{
					val5.Value = ((Component)playerNetworkData).GetComponent<PlayerInteraction>();
				}
			}
			if ((Object)(object)val5.Value != (Object)null)
			{
				Traverse.Create((object)val5.Value).Field<int>("balance").Value = GlobalData.Balance;
				original.Invoke(self);
			}
			((TMP_Text)val4.Value).text = $"<sprite name=\"coin\">{GlobalData.Balance}";
		}
	}
	public static class UIFrameManagerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_OpenMenu <0>__OpenMenu;

			public static hook_ProcessFrameChange <1>__ProcessFrameChange;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__6_0;

			internal void <OpenMenu>b__6_0()
			{
				Plugin.Instance.Network.Local();
				SceneTransitionManagerPatch.Transition("_StartMenu", SceneTransitionManagerPatch.CurrentScene);
			}
		}

		private static RectTransform[] _buttonTransforms;

		private static VerticalLayoutGroup _menuItems;

		private static TFUITextButton _resignButton;

		private static TFUITextButton _disconnectButton;

		private static PauseUILoadoutHelper _pauseUI;

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			object obj = <>O.<0>__OpenMenu;
			if (obj == null)
			{
				hook_OpenMenu val = OpenMenu;
				<>O.<0>__OpenMenu = val;
				obj = (object)val;
			}
			UIFrameManager.OpenMenu += (hook_OpenMenu)obj;
			object obj2 = <>O.<1>__ProcessFrameChange;
			if (obj2 == null)
			{
				hook_ProcessFrameChange val2 = ProcessFrameChange;
				<>O.<1>__ProcessFrameChange = val2;
				obj2 = (object)val2;
			}
			UIFrameManager.ProcessFrameChange += (hook_ProcessFrameChange)obj2;
		}

		private static void OpenMenu(orig_OpenMenu original, UIFrameManager self)
		{
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: 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_022d: 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_0240: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)self.ActiveFrame == (Object)null && !SceneTransitionManagerPatch.InLevelSelect)
			{
				if ((Object)(object)_disconnectButton == (Object)null)
				{
					_pauseUI = ((Component)GameObject.Find("UI Canvas").transform.Find("InMatch Pause Frame")).GetComponent<PauseUILoadoutHelper>();
					Transform val = ((Component)_pauseUI).transform.Find("Title /Menu Items");
					_menuItems = ((Component)val).GetComponent<VerticalLayoutGroup>();
					_resignButton = ((Component)val.Find("Back To Menu")).GetComponent<TFUITextButton>();
					GameObject val2 = Helpers.InstantiateDisabled<GameObject>(((Component)_resignButton).gameObject, ((Component)_resignButton).gameObject.transform.parent, worldPositionStays: false);
					((Object)val2).name = "Disconnect";
					_disconnectButton = val2.GetComponent<TFUITextButton>();
					TextMeshProUGUI component = val2.GetComponent<TextMeshProUGUI>();
					Object.DestroyImmediate((Object)(object)val2.GetComponent<Localize>());
					Traverse.Create((object)_disconnectButton).Field<string>("originalString").Value = "Disconnect";
					((TMP_Text)component).text = "Disconnect";
					((Graphic)component).SetAllDirty();
					Traverse.Create((object)((ThronefallUIElement)_disconnectButton).onApply).Field("m_PersistentCalls").Method("Clear", Array.Empty<object>())
						.GetValue();
					UnityEvent onApply = ((ThronefallUIElement)_disconnectButton).onApply;
					object obj = <>c.<>9__6_0;
					if (obj == null)
					{
						UnityAction val3 = delegate
						{
							Plugin.Instance.Network.Local();
							SceneTransitionManagerPatch.Transition("_StartMenu", SceneTransitionManagerPatch.CurrentScene);
						};
						<>c.<>9__6_0 = val3;
						obj = (object)val3;
					}
					onApply.AddListener((UnityAction)obj);
					((ThronefallUIElement)_disconnectButton).topNav = (ThronefallUIElement)(object)_resignButton;
					((ThronefallUIElement)_disconnectButton).botNav = ((ThronefallUIElement)_resignButton).botNav;
					RectTransform component2 = ((Component)_disconnectButton).GetComponent<RectTransform>();
					Vector2 sizeDelta = component2.sizeDelta;
					sizeDelta.y = 80f;
					component2.sizeDelta = sizeDelta;
					_buttonTransforms = (RectTransform[])(object)new RectTransform[3]
					{
						((Component)val.Find("Continue")).GetComponent<RectTransform>(),
						((Component)val.Find("Settings")).GetComponent<RectTransform>(),
						((Component)_resignButton).GetComponent<RectTransform>()
					};
				}
				if (Plugin.Instance.Network.Online)
				{
					RectTransform[] buttonTransforms = _buttonTransforms;
					foreach (RectTransform val4 in buttonTransforms)
					{
						Vector2 sizeDelta = val4.sizeDelta;
						sizeDelta.y = 80f;
						val4.sizeDelta = sizeDelta;
					}
					((Component)_disconnectButton).gameObject.SetActive(true);
					((ThronefallUIElement)_resignButton).botNav = (ThronefallUIElement)(object)_disconnectButton;
					_pauseUI.botmostButton = (ThronefallUIElement)(object)_disconnectButton;
					((HorizontalOrVerticalLayoutGroup)_menuItems).spacing = 5f;
					_pauseUI.Refresh();
				}
				else
				{
					RectTransform[] buttonTransforms2 = _buttonTransforms;
					foreach (RectTransform val5 in buttonTransforms2)
					{
						Vector2 sizeDelta = val5.sizeDelta;
						sizeDelta.y = 100f;
						val5.sizeDelta = sizeDelta;
					}
					((Component)_disconnectButton).gameObject.SetActive(false);
					((ThronefallUIElement)_resignButton).botNav = ((ThronefallUIElement)_disconnectButton).botNav;
					_pauseUI.botmostButton = (ThronefallUIElement)(object)_resignButton;
					((HorizontalOrVerticalLayoutGroup)_menuItems).spacing = 10f;
					_pauseUI.Refresh();
				}
			}
			original.Invoke(self);
		}

		private static void ProcessFrameChange(orig_ProcessFrameChange original, UIFrameManager self, UIFrame nextframe, bool writeoldframetostack, bool keepoldframegameobjectactive, ThronefallUIElement firstselected)
		{
			if ((Object)(object)nextframe != (Object)null)
			{
				nextframe.freezeTime = false;
			}
			original.Invoke(self, nextframe, writeoldframetostack, keepoldframegameobjectactive, firstselected);
		}
	}
	public class UIFramePatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_HandleButtonNavigation <0>__HandleButtonNavigation;

			public static hook_HandleMouseNavigation <1>__HandleMouseNavigation;
		}

		public static int DisableGameUIInputCount;

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			//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_003d: Expected O, but got Unknown
			object obj = <>O.<0>__HandleButtonNavigation;
			if (obj == null)
			{
				hook_HandleButtonNavigation val = HandleButtonNavigation;
				<>O.<0>__HandleButtonNavigation = val;
				obj = (object)val;
			}
			UIFrame.HandleButtonNavigation += (hook_HandleButtonNavigation)obj;
			object obj2 = <>O.<1>__HandleMouseNavigation;
			if (obj2 == null)
			{
				hook_HandleMouseNavigation val2 = HandleMouseNavigation;
				<>O.<1>__HandleMouseNavigation = val2;
				obj2 = (object)val2;
			}
			UIFrame.HandleMouseNavigation += (hook_HandleMouseNavigation)obj2;
		}

		private static void HandleButtonNavigation(orig_HandleButtonNavigation original, UIFrame self)
		{
			if (DisableGameUIInputCount == 0)
			{
				original.Invoke(self);
			}
		}

		private static void HandleMouseNavigation(orig_HandleMouseNavigation original, UIFrame self)
		{
			if (DisableGameUIInputCount == 0)
			{
				original.Invoke(self);
			}
		}
	}
	public class UnitRespawnerForBuildingsPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_RespawnAKnockedOutUnit <0>__RespawnAKnockedOutUnit;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			object obj = <>O.<0>__RespawnAKnockedOutUnit;
			if (obj == null)
			{
				hook_RespawnAKnockedOutUnit val = RespawnAKnockedOutUnit;
				<>O.<0>__RespawnAKnockedOutUnit = val;
				obj = (object)val;
			}
			UnitRespawnerForBuildings.RespawnAKnockedOutUnit += (hook_RespawnAKnockedOutUnit)obj;
		}

		private static void RespawnAKnockedOutUnit(orig_RespawnAKnockedOutUnit original, UnitRespawnerForBuildings self)
		{
			if (Plugin.Instance.Network.Server)
			{
				original.Invoke(self);
			}
		}
	}
	public static class UpgradeAssassinsTrainingPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_OnEnable <0>__OnEnable;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			object obj = <>O.<0>__OnEnable;
			if (obj == null)
			{
				hook_OnEnable val = OnEnable;
				<>O.<0>__OnEnable = val;
				obj = (object)val;
			}
			UpgradeAssassinsTraining.OnEnable += (hook_OnEnable)obj;
		}

		private static void OnEnable(orig_OnEnable original, UpgradeAssassinsTraining self)
		{
			UpgradeAssassinsTraining.instance = self;
			PlayerUpgradeManager.instance.assassinsTraining = Object.op_Implicit((Object)(object)self);
			foreach (PlayerManager.Player allPlayer in Plugin.Instance.PlayerManager.GetAllPlayers())
			{
				if ((Object)(object)allPlayer.Object == (Object)null)
				{
					continue;
				}
				ManualAttack[] componentsInChildren = allPlayer.Object.GetComponentsInChildren<ManualAttack>(true);
				foreach (ManualAttack val in componentsInChildren)
				{
					if (val.autoAttack)
					{
						val.cooldownTime *= self.autoAttackCooldownDurationMulti;
					}
					else
					{
						val.cooldownTime *= self.manualAttackCooldownDurationMulti;
					}
				}
			}
		}
	}
	public static class WeaponEquipperPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__Start;
		}

		public static void Apply()
		{
			//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_001c: Expected O, but got Unknown
			object obj = <>O.<0>__Start;
			if (obj == null)
			{
				hook_Start val = Start;
				<>O.<0>__Start = val;
				obj = (object)val;
			}
			WeaponEquipper.Start += (hook_Start)obj;
		}

		private static void Start(orig_Start original, WeaponEquipper self)
		{
			Equipment equipment = Equip.Convert(self.requiredWeapon);
			Equipment equipment2 = equipment;
			Equipment equipment3 = equipment2;
			if ((uint)(equipment3 - 2) <= 2u)
			{
				Identifier componentInParent = ((Component)self).GetComponentInParent<Identifier>();
				if (!((Object)(object)componentInParent == (Object)null) && componentInParent.Type == IdentifierType.Player && Plugin.Instance.PlayerManager.Get((int)componentInParent.Id)?.Weapon == equipment)
				{
					((Component)self).GetComponentInParent<PlayerInteraction>().EquipWeapon(self.activeWeapon, self.passiveWeapon);
					((Component)self).GetComponentInParent<PlayerUpgradeManager>();
					((Component)self).GetComponentInParent<PlayerAttack>().AssignManualAttack(self.activeWeapon);
					((Component)self).gameObject.AddComponent<PlayerWeaponVisuals>().Init(self.visuals, self.passiveWeapon);
					self.facer.AssignAttack(self.passiveWeapon);
					Object.Destroy((Object)(object)self);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)self).gameObject);
				}
			}
			else
			{
				original.Invoke(self);
			}
		}
	}
}
namespace ThronefallMP.Network
{
	public static class BossSpawnRegistry
	{
		private static List<Spawn> _spawns;

		static BossSpawnRegistry()
		{
			SceneManager.sceneLoaded += delegate
			{
				_spawns = null;
			};
		}

		public static int GetRef(Spawn spawn)
		{
			EnsureBuilt();
			return _spawns.IndexOf(spawn);
		}

		public static Spawn Resolve(int index)
		{
			EnsureBuilt();
			return (index >= 0 && index < _spawns.Count) ? _spawns[index] : null;
		}

		private static void EnsureBuilt()
		{
			if (_spawns != null)
			{
				return;
			}
			List<(string, int, Spawn)> list = new List<(string, int, Spawn)>();
			Ghostqueen[] array = Object.FindObjectsOfType<Ghostqueen>(true);
			foreach (Ghostqueen val in array)
			{
				Spawn value = Traverse.Create((object)val).Field<Spawn>("waveToSpawn").Value;
				if (value != null)
				{
					list.Add((Helpers.GetPath(((Component)val).transform), 0, value));
				}
			}
			KeyframedBoss[] array2 = Object.FindObjectsOfType<KeyframedBoss>(true);
			foreach (KeyframedBoss val2 in array2)
			{
				Wave value2 = Traverse.Create((object)val2).Field<Wave>("waveToSpawn").Value;
				if (value2?.spawns != null)
				{
					for (int k = 0; k < value2.spawns.Count; k++)
					{
						list.Add((Helpers.GetPath(((Component)val2).transform), k, value2.spawns[k]));
					}
				}
			}
			list.Sort(delegate((string path, int index, Spawn spawn) a, (string path, int index, Spawn spawn) b)
			{
				int num = string.CompareOrdinal(a.path, b.path);
				return (num != 0) ? num : a.index.CompareTo(b.index);
			});
			_spawns = new List<Spawn>(list.Count);
			foreach (var item in list)
			{
				_spawns.Add(item.Item3);
			}
		}
	}
	public class Buffer
	{
		public byte[] Data;

		public int ReadHead;

		public int WriteHead;

		public bool LastReadFailed;

		public Buffer()
			: this(32)
		{
		}

		public Buffer(int capacity)
		{
			Data = new byte[capacity];
		}

		private void EnsureSize(int extra)
		{
			if (WriteHead + extra > Data.Length)
			{
				Array.Resize(ref Data, Data.Length * 2);
			}
		}

		public bool CanRead(int size)
		{
			return ReadHead + size <= Data.Length;
		}

		private bool CanReadInternal(int size)
		{
			bool flag = CanRead(size);
			LastReadFailed = !flag;
			return flag;
		}

		public void Write(bool value)
		{
			byte[] bytes = BitConverter.GetBytes(value);
			EnsureSize(bytes.Length);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(bytes);
			}
			bytes.CopyTo(Data, WriteHead);
			WriteHead += bytes.Length;
		}

		public void Write(byte value)
		{
			EnsureSize(1);
			Data[WriteHead] = value;
			WriteHead++;
		}

		public void Write(short value)
		{
			byte[] bytes = BitConverter.GetBytes(value);
			EnsureSize(bytes.Length);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(bytes);
			}
			bytes.CopyTo(Data, WriteHead);
			WriteHead += bytes.Length;
		}

		public void Write(ushort value)
		{
			byte[] bytes = BitConverter.GetBytes(value);
			EnsureSize(bytes.Length);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(bytes);
			}
			bytes.CopyTo(Data, WriteHead);
			WriteHead += bytes.Length;
		}

		public void Write(int value)
		{
			byte[] bytes = BitConverter.GetBytes(value);
			EnsureSize(bytes.Length);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(bytes);
			}
			bytes.CopyTo(Data, WriteHead);
			WriteHead += bytes.Length;
		}

		public void Write(uint value)
		{
			byte[] bytes = BitConverter.GetBytes(value);
			EnsureSize(bytes.Length);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(bytes);
			}
			bytes.CopyTo(Data, WriteHead);
			WriteHead += bytes.Length;
		}

		public void Write(long value)
		{
			byte[] bytes = BitConverter.GetBytes(value);
			EnsureSize(bytes.Length);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(bytes);
			}
			bytes.CopyTo(Data, WriteHead);
			WriteHead += bytes.Length;
		}

		public void Write(ulong value)
		{
			byte[] bytes = BitConverter.GetBytes(value);
			EnsureSize(bytes.Length);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(bytes);
			}
			bytes.CopyTo(Data, WriteHead);
			WriteHead += bytes.Length;
		}

		public void Write(float value)
		{
			byte[] bytes = BitConverter.GetBytes(value);
			EnsureSize(bytes.Length);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(bytes);
			}
			bytes.CopyTo(Data, WriteHead);
			WriteHead += bytes.Length;
		}

		public void Write(ThronefallMP.Utils.Half value)
		{
			byte[] bytes = ThronefallMP.Utils.Half.GetBytes(value);
			EnsureSize(bytes.Length);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(bytes);
			}
			bytes.CopyTo(Data, WriteHead);
			WriteHead += bytes.Length;
		}

		public void Write(string value)
		{
			if (value == null)
			{
				Write((ushort)0);
				return;
			}
			byte[] bytes = Encoding.ASCII.GetBytes(value);
			Write((ushort)bytes.Length);
			EnsureSize(bytes.Length);
			bytes.CopyTo(Data, WriteHead);
			WriteHead += bytes.Length;
		}

		public void Write(Vector3 value, bool half = false)
		{
			//IL_0042: 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_005c: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (half)
			{
				Write((ThronefallMP.Utils.Half)value.x);
				Write((ThronefallMP.Utils.Half)value.y);
				Write((ThronefallMP.Utils.Half)value.z);
			}
			else
			{
				Write(value.x);
				Write(value.y);
				Write(value.z);
			}
		}

		public void Write(Quaternion value, bool half = false)
		{
			//IL_0054: 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_006e: 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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (half)
			{
				Write((ThronefallMP.Utils.Half)value.x);
				Write((ThronefallMP.Utils.Half)value.y);
				Write((ThronefallMP.Utils.Half)value.z);
				Write((ThronefallMP.Utils.Half)value.w);
			}
			else
			{
				Write(value.x);
				Write(value.y);
				Write(value.z);
				Write(value.w);
			}
		}

		public void Write(PacketId value)
		{
			Write((byte)value);
		}

		public void Write(Equipment value)
		{
			Write((byte)value);
		}

		public void Write(IdentifierData value)
		{
			Write((byte)value.Type);
			Write(value.Id);
		}

		public void Write(CSteamID value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			byte[] bytes = BitConverter.GetBytes(value.m_SteamID);
			EnsureSize(bytes.Length);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(bytes);
			}
			bytes.CopyTo(Data, WriteHead);
			WriteHead += bytes.Length;
		}

		public byte ReadByte()
		{
			if (!CanReadInternal(1))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read byte");
				return 0;
			}
			ReadHead++;
			return Data[ReadHead - 1];
		}

		public bool ReadBoolean()
		{
			if (!CanReadInternal(1))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read bool");
				return false;
			}
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 1);
			}
			bool result = BitConverter.ToBoolean(Data, ReadHead);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 1);
			}
			ReadHead++;
			return result;
		}

		public ushort ReadUInt16()
		{
			if (!CanReadInternal(2))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read int");
				return 0;
			}
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 2);
			}
			ushort result = BitConverter.ToUInt16(Data, ReadHead);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 2);
			}
			ReadHead += 2;
			return result;
		}

		public int ReadInt32()
		{
			if (!CanReadInternal(4))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read int");
				return 0;
			}
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 4);
			}
			int result = BitConverter.ToInt32(Data, ReadHead);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 4);
			}
			ReadHead += 4;
			return result;
		}

		public uint ReadUInt32()
		{
			if (!CanReadInternal(4))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read int");
				return 0u;
			}
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 4);
			}
			uint result = BitConverter.ToUInt32(Data, ReadHead);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 4);
			}
			ReadHead += 4;
			return result;
		}

		public long ReadInt64()
		{
			if (!CanReadInternal(8))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read long");
				return 0L;
			}
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 8);
			}
			long result = BitConverter.ToInt64(Data, ReadHead);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 8);
			}
			ReadHead += 8;
			return result;
		}

		public ulong ReadUInt64()
		{
			if (!CanReadInternal(8))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read long");
				return 0uL;
			}
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 8);
			}
			ulong result = BitConverter.ToUInt64(Data, ReadHead);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 8);
			}
			ReadHead += 8;
			return result;
		}

		public ThronefallMP.Utils.Half ReadHalf()
		{
			if (!CanReadInternal(2))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read half");
				return new ThronefallMP.Utils.Half(0);
			}
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 2);
			}
			ThronefallMP.Utils.Half result = ThronefallMP.Utils.Half.ToHalf(Data, ReadHead);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 4);
			}
			ReadHead += 2;
			return result;
		}

		public float ReadFloat()
		{
			if (!CanReadInternal(4))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read float");
				return 0f;
			}
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 4);
			}
			float result = BitConverter.ToSingle(Data, ReadHead);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(Data, ReadHead, 4);
			}
			ReadHead += 4;
			return result;
		}

		public string ReadString()
		{
			int readHead = ReadHead;
			ushort num = ReadUInt16();
			if (LastReadFailed)
			{
				Plugin.Log.LogInfoFiltered("Buffer", $"Failed to read string length ({readHead}:{Data.Length})");
				ReadHead = readHead;
				return "";
			}
			if (!CanReadInternal(num))
			{
				Plugin.Log.LogInfoFiltered("Buffer", $"Failed to read string of length {num} ({readHead}:{Data.Length})");
				ReadHead = readHead;
				return "";
			}
			string result = Encoding.ASCII.GetString(Data, ReadHead, num);
			ReadHead += num;
			return result;
		}

		public Vector3 ReadVector3Half()
		{
			//IL_0003: 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_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_006b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 result = default(Vector3);
			if (!CanReadInternal(6))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read half vector3");
				return result;
			}
			result.x = ReadHalf();
			result.y = ReadHalf();
			result.z = ReadHalf();
			return result;
		}

		public Vector3 ReadVector3()
		{
			//IL_0003: 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_005a: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			Vector3 result = default(Vector3);
			if (!CanReadInternal(12))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read vector3");
				return result;
			}
			result.x = ReadFloat();
			result.y = ReadFloat();
			result.z = ReadFloat();
			return result;
		}

		public Quaternion ReadQuaternionHalf()
		{
			//IL_0003: 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_007a: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			Quaternion result = default(Quaternion);
			if (!CanReadInternal(8))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read half quaternion");
				return result;
			}
			result.x = ReadHalf();
			result.y = ReadHalf();
			result.z = ReadHalf();
			result.w = ReadHalf();
			return result;
		}

		public Quaternion ReadQuaternion()
		{
			//IL_0003: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			Quaternion result = default(Quaternion);
			if (!CanReadInternal(16))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read quaternion");
				return result;
			}
			result.x = ReadFloat();
			result.y = ReadFloat();
			result.z = ReadFloat();
			result.w = ReadFloat();
			return result;
		}

		public PacketId ReadPacketId()
		{
			return (PacketId)ReadByte();
		}

		public Equipment ReadEquipment()
		{
			return (Equipment)ReadByte();
		}

		public IdentifierData ReadIdentifierData()
		{
			if (!CanReadInternal(3))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read identifier");
				return IdentifierData.Invalid;
			}
			IdentifierData result = default(IdentifierData);
			result.Type = (IdentifierType)ReadByte();
			result.Id = ReadUInt16();
			return result;
		}

		public CSteamID ReadSteamID()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (!CanReadInternal(8))
			{
				Plugin.Log.LogInfoFiltered("Buffer", "Failed to read identifier");
				return CSteamID.Nil;
			}
			return new CSteamID(ReadUInt64());
		}
	}
	public static class HostUnlocks
	{
		public static readonly HashSet<Equipment> Session = new HashSet<Equipment>();

		public static void Reset()
		{
			Session.Clear();
		}
	}
	public static class LoadoutState
	{
		public static readonly Dictionary<ushort, Equipment> WeaponPicks = new Dictionary<ushort, Equipment>();

		public static bool RemoteOpenPending;

		public static bool RemoteClosePending;

		public static bool SuppressNextDiff;

		public static void Reset()
		{
			WeaponPicks.Clear();
			RemoteOpenPending = false;
			RemoteClosePending = false;
			SuppressNextDiff = false;
		}
	}
	public struct Lobby
	{
		public CSteamID Id;

		public string Name;

		public bool HasPassword;

		public int PlayerCount;

		public int MaxPlayerCount;
	}
	public enum Channel
	{
		NetworkManagement,
		Player,
		SyncPlayer,
		SyncUnit,
		SyncPositions,
		Resources,
		Game
	}
	public class Network : MonoBehaviour
	{
		public delegate void OwnerChangedHandler(CSteamID owner);

		public delegate bool ChatMessageHandler(string user, string message);

		private const int MaxMessages = 100;

		[UsedImplicitly]
		private Callback<LobbyChatUpdate_t> _lobbyChatUpdate;

		[UsedImplicitly]
		private Callback<GameLobbyJoinRequested_t> _lobbyJoinRequested;

		[UsedImplicitly]
		private Callback<LobbyChatMsg_t> _lobbyChatMessage;

		[UsedImplicitly]
		private Callback<SteamNetworkingMessagesSessionRequest_t> _sessionRequestCallback;

		[UsedImplicitly]
		private Callback<SteamNetworkingMessagesSessionFailed_t> _sessionFailed;

		private CallResult<LobbyEnter_t> _lobbyEnterResult;

		private readonly HashSet<CSteamID> _pendingPeers = new HashSet<CSteamID>();

		private readonly HashSet<CSteamID> _peers = new HashSet<CSteamID>();

		private readonly Dictionary<(int player, Channel channel), int> _lastOrderedPackages = new Dictionary<(int, Channel), int>();

		private readonly IntPtr[] _messages = new IntPtr[100];

		private List<(int priority, ChatMessageHandler handler)> _messageHandlers = new List<(int, ChatMessageHandler)>();

		private string _password;

		private byte[] _chatBuffer = new byte[4096];

		private static readonly Dictionary<PacketId, Type> PendingPeerPacketTypes = new Dictionary<PacketId, Type> { 
		{
			PacketId.Approval,
			typeof(ApprovalPacket)
		} };

		private static readonly Dictionary<PacketId, Type> PacketTypes = new Dictionary<PacketId, Type>
		{
			{
				PacketId.Disconnect,
				typeof(DisconnectPacket)
			},
			{
				PacketId.PeerSync,
				typeof(PeerListPacket)
			},
			{
				PacketId.SyncPing,
				typeof(SyncPingPacket)
			},
			{
				PacketId.SyncPong,
				typeof(SyncPongPacket)
			},
			{
				PacketId.SyncPingInfo,
				typeof(SyncPingInfoPacket)
			},
			{
				PacketId.SyncAllyPathfinder,
				typeof(SyncAllyPathfinderPacket)
			},
			{
				PacketId.SyncEnemyPathfinder,
				typeof(SyncEnemyPathfinderPacket)
			},
			{
				PacketId.SyncHp,
				typeof(SyncHpPacket)
			},
			{
				PacketId.SyncLevelData,
				typeof(SyncLevelDataPacket)
			},
			{
				PacketId.SyncPlayerInput,
				typeof(SyncPlayerInputPacket)
			},
			{
				PacketId.SyncPlayer,
				typeof(SyncPlayersPacket)
			},
			{
				PacketId.SyncPosition,
				typeof(SyncPositionPacket)
			},
			{
				PacketId.SyncResource,
				typeof(SyncResourcePacket)
			},
			{
				PacketId.BossSpawn,
				typeof(BossSpawnPacket)
			},
			{
				PacketId.LoadoutOpen,
				typeof(LoadoutOpenPacket)
			},
			{
				PacketId.LoadoutSelection,
				typeof(LoadoutSelectionPacket)
			},
			{
				PacketId.LoadoutWeapon,
				typeof(LoadoutWeaponPacket)
			},
			{
				PacketId.LoadoutClose,
				typeof(LoadoutClosePacket)
			},
			{
				PacketId.LoadoutStateRequest,
				typeof(LoadoutStateRequestPacket)
			},
			{
				PacketId.HostUnlocks,
				typeof(HostUnlocksPacket)
			},
			{
				PacketId.Combined,
				typeof(CombinedPacket)
			},
			{
				PacketId.DamageFeedback,
				typeof(DamageFeedbackPacket)
			},
			{
				PacketId.DayNight,
				typeof(DayNightPacket)
			},
			{
				PacketId.EnemySpawn,
				typeof(EnemySpawnPacket)
			},
			{
				PacketId.LockTarget,
				typeof(LockTargetPacket)
			},
			{
				PacketId.RequestLevel,
				typeof(RequestLevelPacket)
			},
			{
				PacketId.RestartLevel,
				typeof(RestartLevelPacket)
			},
			{
				PacketId.Resign,
				typeof(ResignPacket)
			},
			{
				PacketId.Victory,
				typeof(VictoryPacket)
			},
			{
				PacketId.TeleportPlayer,
				typeof(TeleportPlayerPacket)
			},
			{
				PacketId.WeaponRequest,
				typeof(WeaponRequestPacket)
			},
			{
				PacketId.WeaponResponse,
				typeof(WeaponResponsePacket)
			},
			{
				PacketId.BuildOrUpgrade,
				typeof(BuildOrUpgradePacket)
			},
			{
				PacketId.CancelBuild,
				typeof(CancelBuildPacket)
			},
			{
				PacketId.CommandAdd,
				typeof(CommandAddPacket)
			},
			{
				PacketId.CommandPlace,
				typeof(CommandPlacePacket)
			},
			{
				PacketId.CommandHoldPosition,
				typeof(CommandHoldPositionPacket)
			},
			{
				PacketId.ConfirmBuild,
				typeof(ConfirmBuildPacket)
			},
			{
				PacketId.ManualAttack,
				typeof(ManualAttackPacket)
			}
		};

		public IEnumerable<CSteamID> Peers => _peers;

		public int MaxPlayers { get; set; }

		public bool Authority => Server || !Online;

		public bool Server { get; private set; }

		public bool Online { get; private set; }

		public CSteamID Owner { get; private set; }

		public CSteamID Lobby { get; private set; }

		public static CSteamID SteamId => SteamUser.GetSteamID();

		public event OwnerChangedHandler OnOwnerChanged;

		public void Awake()
		{
			_sessionRequestCallback = Callback<SteamNetworkingMessagesSessionRequest_t>.Create((DispatchDelegate<SteamNetworkingMessagesSessionRequest_t>)OnSessionRequest);
			_sessionFailed = Callback<SteamNetworkingMessagesSessionFailed_t>.Create((DispatchDelegate<SteamNetworkingMessagesSessionFailed_t>)OnSessionFailed);
			_lobbyChatUpdate = Callback<LobbyChatUpdate_t>.Create((DispatchDelegate<LobbyChatUpdate_t>)OnLobbyChatUpdate);
			_lobbyJoinRequested = Callback<GameLobbyJoinRequested_t>.Create((DispatchDelegate<GameLobbyJoinRequested_t>)OnGameLobbyJoinRequested);
			_lobbyEnterResult = CallResult<LobbyEnter_t>.Create((APIDispatchDelegate<LobbyEnter_t>)OnLobbyEntered);
			_lobbyChatMessage = Callback<LobbyChatMsg_t>.Create((DispatchDelegate<LobbyChatMsg_t>)OnChatMessageReceived);
			SceneManager.sceneLoaded += OnSceneChanged;
		}

		private void OnChatMessageReceived(LobbyChatMsg_t chat)
		{
			//IL_0001: 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_000a: Invalid comparison between Unknown and I4
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			EChatEntryType val = (EChatEntryType)chat.m_eChatEntryType;
			if ((int)val != 1)
			{
				return;
			}
			CSteamID val2 = default(CSteamID);
			int lobbyChatEntry = SteamMatchmaking.GetLobbyChatEntry(new CSteamID(chat.m_ulSteamIDLobby), (int)chat.m_iChatID, ref val2, _chatBuffer, _chatBuffer.Length, ref val);
			Buffer buffer = new Buffer
			{
				Data = _chatBuffer
			};
			byte b = buffer.ReadByte();
			string message = buffer.ReadString();
			if (buffer.ReadHead != lobbyChatEntry)
			{
				Plugin.Log.LogWarningFiltered("Network", "Received chat message of invalid length.");
			}
			switch (b)
			{
			case 0:
			{
				string friendPersonaName = SteamFriends.GetFriendPersonaName(val2);
				HandleMessage(friendPersonaName, message);
				break;
			}
			case 1:
				if (val2 == Owner)
				{
					HandleMessage("Server", message);
				}
				break;
			}
		}

		private void HandleMessage(string user, string message)
		{
			using List<(int, ChatMessageHandler)>.Enumerator enumerator = _messageHandlers.GetEnumerator();
			while (enumerator.MoveNext() && !enumerator.Current.Item2(user, message))
			{
			}
		}

		public void SendChatMessage(string message)
		{
			//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_0030: Unknown result type (might be due to invalid IL or missing references)
			CSteamID lobby = Lobby;
			if (((CSteamID)(ref lobby)).IsValid())
			{
				Buffer buffer = new Buffer();
				buffer.Write((byte)0);
				buffer.Write(message);
				SteamMatchmaking.SendLobbyChatMsg(Lobby, buffer.Data, buffer.WriteHead);
			}
		}

		public void SendServerMessage(string message)
		{
			//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_0038: Unknown result type (might be due to invalid IL or missing references)
			CSteamID lobby = Lobby;
			if (((CSteamID)(ref lobby)).IsValid() || !Server)
			{
				Buffer buffer = new Buffer();
				buffer.Write((byte)1);
				buffer.Write(message);
				SteamMatchmaking.SendLobbyChatMsg(Lobby, buffer.Data, buffer.WriteHead);
			}
		}

		public void AddChatMessageHandler(int priority, ChatMessageHandler handler)
		{
			_messageHandlers.Add((priority, handler));
			_messageHandlers.Sort(((int priority, ChatMessageHandler handler) a, (int priority, ChatMessageHandler handler) b) => b.priority.CompareTo(a.priority));
		}

		public bool Authenticate(string password)
		{
			Plugin.Log.LogInfoFiltered("Network", "Comparing " + password + " with " + _password);
			return string.IsNullOrEmpty(_password) || _password == password;
		}

		public void AddPlayer(CSteamID id)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_008a: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0182: 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_01ca: 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_01f5: 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_0206: Unknown result type (might be due to invalid IL or missing references)
			SyncManager.OnConnected(id);
			_peers.Add(id);
			_pendingPeers.Remove(id);
			PlayerManager.Player player = Plugin.Instance.PlayerManager.CreateOrGet(id, Plugin.Instance.PlayerManager.GenerateID());
			player.SpawnID = (byte)(Plugin.Instance.PlayerManager.GetAllPlayers().Max((PlayerManager.Player p) => p.SpawnID) + 1);
			Plugin.Instance.PlayerManager.InstantiatePlayer(player, player.SpawnLocation);
			string friendPersonaName = SteamFriends.GetFriendPersonaName(id);
			HandleMessage("Server", friendPersonaName + " joined");
			PeerListPacket peerListPacket = new PeerListPacket();
			Plugin.Log.LogInfoFiltered("Network", "Building peer sync");
			foreach (PlayerManager.Player allPlayer in Plugin.Instance.PlayerManager.GetAllPlayers())
			{
				Plugin.Log.LogInfoFiltered("Network", $" {allPlayer.SteamID}:{allPlayer.Id} -> {allPlayer.Object.transform.position}");
				peerListPacket.Players.Add(new PeerListPacket.PlayerData
				{
					Id = allPlayer.Id,
					SteamId = allPlayer.SteamID,
					SpawnId = allPlayer.SpawnID,
					Position = allPlayer.Object.transform.position
				});
			}
			Plugin.Log.LogInfoFiltered("Network", "Sending peer sync");
			Send(peerListPacket);
			HostUnlocksPacket hostUnlocksPacket = PacketHandler.BuildHostUnlocksPacket();
			if (hostUnlocksPacket.Unlocks.Count > 0)
			{
				SteamNetworkingIdentity target = default(SteamNetworkingIdentity);
				((SteamNetworkingIdentity)(ref target)).SetSteamID(id);
				SendSingle(hostUnlocksPacket, target);
			}
		}

		public void KickPeer(CSteamID id, DisconnectPacket.Reason reason)
		{
			//IL_000b: 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_0070: 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_0081: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			PlayerManager.Player player = Plugin.Instance.PlayerManager.Get(id);
			if (player != null)
			{
				Plugin.Log.LogInfoFiltered("Network", $"Player {id.m_SteamID} kicked with reason {reason}");
				Plugin.Instance.PlayerManager.Remove(player.Id);
			}
			_peers.Remove(id);
			_pendingPeers.Remove(id);
			SteamNetworkingIdentity target = default(SteamNetworkingIdentity);
			((SteamNetworkingIdentity)(ref target)).SetSteamID(id);
			DisconnectPacket basePacket = new DisconnectPacket
			{
				DisconnectReason = reason
			};
			SendSingle(basePacket, target);
		}

		private void OnSessionFailed(SteamNetworkingMessagesSessionFailed_t failed)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			_peers.Remove(((SteamNetworkingIdentity)(ref failed.m_info.m_identityRemote)).GetSteamID());
			if (!Server)
			{
				Online = _peers.Count != 0;
				Server = true;
			}
		}

		private bool HandleChannel(Channel channel)
		{
			//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)
			//IL_0034: 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_0043: 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_00a3: 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)
			int num = SteamNetworkingMessages.ReceiveMessagesOnChannel((int)channel, _messages, 100);
			for (int i = 0; i < num; i++)
			{
				try
				{
					SteamNetworkingMessage_t val = Marshal.PtrToStructure<SteamNetworkingMessage_t>(_messages[i]);
					if (_peers.Contains(((SteamNetworkingIdentity)(ref val.m_identityPeer)).GetSteamID()))
					{
						Buffer buffer = new Buffer(val.m_cbSize);
						Marshal.Copy(val.m_pData, buffer.Data, 0, buffer.Data.Length);
						HandlePacket(ref val.m_identityPeer, buffer, PacketTypes);
					}
					else if (_pendingPeers.Contains(((SteamNetworkingIdentity)(ref val.m_identityPeer)).GetSteamID()))
					{
						Buffer buffer2 = new Buffer(val.m_cbSize);
						Marshal.Copy(val.m_pData, buffer2.Data, 0, buffer2.Data.Length);
						HandlePacket(ref val.m_identityPeer, buffer2, PendingPeerPacketTypes);
					}
				}
				catch (Exception arg)
				{
					Plugin.Log.LogError((object)$"Exception handling packet on channel {channel}: {arg}");
				}
				finally
				{
					SteamNetworkingMessage_t.Release(_messages[i]);
				}
			}
			return num != 0;
		}

		private void Update()
		{
			if (_peers.Count <= 0 && _pendingPeers.Count <= 0)
			{
				return;
			}
			foreach (object value in Enum.GetValues(typeof(Channel)))
			{
				while (HandleChannel((Channel)value))
				{
				}
			}
		}

		private void LateUpdate()
		{
			if (Online)
			{
				SyncManager.UpdateSyncs();
			}
		}

		private void CloseLobby()
		{
			//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_0055: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			SyncManager.ResetSyncs();
			LoadoutState.Reset();
			HostUnlocks.Reset();
			if (PacketHandler.AwaitingConnectionApproval)
			{
				UIManager.LobbyListPanel.CloseConnectingDialog();
				PacketHandler.AwaitingConnectionApproval = false;
			}
			CSteamID lobby = Lobby;
			if (((CSteamID)(ref lobby)).IsValid())
			{
				Plugin.Log.LogInfoFiltered("Network", $"Leaving lobby {Lobby.m_SteamID}");
				SteamMatchmaking.LeaveLobby(Lobby);
				foreach (CSteamID peer in _peers)
				{
					SteamNetworkingIdentity val = default(SteamNetworkingIdentity);
					((SteamNetworkingIdentity)(ref val)).SetSteamID(peer);
					SteamNetworkingMessages.CloseSessionWithUser(ref val);
				}
				_peers.Clear();
				lobby = Lobby;
				((CSteamID)(ref lobby)).Clear();
			}
			_password = null;
			_lastOrderedPackages.Clear();
		}

		public void Local()
		{
			//IL_0066: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			CloseLobby();
			Plugin.Log.LogInfoFiltered("Network", "Switched to Local");
			Server = true;
			Online = false;
			Plugin.Instance.PlayerManager.Clear();
			Plugin.Instance.PlayerManager.LocalId = Plugin.Instance.PlayerManager.GenerateID();
			PlayerManager.Player player = Plugin.Instance.PlayerManager.CreateOrGet(CSteamID.Nil, Plugin.Instance.PlayerManager.LocalId);
			player.SpawnID = 0;
			Owner = CSteamID.Nil;
			Plugin.Instance.PlayerManager.InstantiatePlayer(player, player.SpawnLocation);
		}

		public void Host(CSteamID lobby, string password)
		{
			//IL_0017: 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_003f: 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_009c: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			CloseLobby();
			Plugin.Log.LogInfoFiltered("Network", $"Switched to Host in lobby {lobby.m_SteamID} server {SteamUser.GetSteamID()}");
			_password = password;
			Lobby = lobby;
			Owner = SteamUser.GetSteamID();
			Server = true;
			Online = true;
			Plugin.Instance.PlayerManager.Clear();
			Plugin.Instance.PlayerManager.LocalId = Plugin.Instance.PlayerManager.GenerateID();
			PlayerManager.Player player = Plugin.Instance.PlayerManager.CreateOrGet(Owner, Plugin.Instance.PlayerManager.LocalId);
			player.SpawnID = 0;
			Plugin.Instance.PlayerManager.InstantiatePlayer(player, player.SpawnLocation);
			SteamMatchmaking.SetLobbyJoinable(lobby, true);
		}

		public void ConnectLobby(CSteamID lobby, string password)
		{
			//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)
			CloseLobby();
			_password = password;
			_lobbyEnterResult.Set(SteamMatchmaking.JoinLobby(lobby), (APIDispatchDelegate<LobbyEnter_t>)null);
		}

		private void Connect(CSteamID lobby, string password)
		{
			//IL_001e: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogInfoFiltered("Network", "Switched to Connect");
			_password = password;
			Lobby = lobby;
			Server = false;
			Online = true;
			Plugin.Instance.PlayerManager.Clear();
			Owner = SteamMatchmaking.GetLobbyOwner(lobby);
			Plugin.Log.LogInfoFiltered("Network", $"Sending approval packet to server {Owner.m_SteamID}");
			PacketHandler.AwaitingConnectionApproval = true;
			_peers.Add(Owner);
			((MonoBehaviour)this).StartCoroutine(GetApproval(password));
		}

		private IEnumerator GetApproval(string password)
		{
			ApprovalPacket approvalPacket = new ApprovalPacket
			{
				Password = password
			};
			SteamNetworkingIdentity id = default(SteamNetworkingIdentity);
			((SteamNetworkingIdentity)(ref id)).SetSteamID(Owner);
			while (PacketHandler.AwaitingConnectionApproval)
			{
				SendSingle(approvalPacket, id);
				yield return (object)new WaitForSeconds(2f);
			}
		}

		private void OnSceneChanged(Scene scene, LoadSceneMode mode)
		{
			//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_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_00b4: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogInfoFiltered("Network", "Scene loaded '" + ((Scene)(ref scene)).name + "'");
			if (((Scene)(ref scene)).name == "_StartMenu")
			{
				Plugin.Instance.PlayerManager.SetPrefab(null);
				Local();
			}
			else if (Server && Online)
			{
				CSteamID lobby = Lobby;
				if (((CSteamID)(ref lobby)).IsValid())
				{
					ManualLogSource log = Plugin.Log;
					Scene sceneByName = SceneManager.GetSceneByName("_LevelSelect");
					log.LogInfoFiltered("Network", $"Can join lobby: {((Scene)(ref sceneByName)).isLoaded}");
					CSteamID lobby2 = Lobby;
					sceneByName = SceneManager.GetSceneByName("_LevelSelect");
					SteamMatchmaking.SetLobbyJoinable(lobby2, ((Scene)(ref sceneByName)).isLoaded);
				}
			}
		}

		public void Send(BasePacket basePacket, bool handleLocal = false, CSteamID except = default(CSteamID))
		{
			//IL_0048: 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)
			//IL_010b: 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_0195: 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)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: 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)
			if (basePacket is LoadoutOpenPacket loadoutOpenPacket)
			{
				Plugin.Log.LogInfo((object)$"[LoadoutDiag] tx LoadoutOpen scene={loadoutOpenPacket.Scene} peers={_peers.Count} handleLocal={handleLocal} except={except.m_SteamID}");
			}
			if (Online && _peers.Count > 0)
			{
				Buffer buffer = new Buffer();
				Plugin.Log.LogDebugFiltered("Network", $"Writing packet '{basePacket.TypeID}'");
				buffer.Write(basePacket.TypeID);
				basePacket.Send(buffer);
				if (Ext.LogDebugFiltered("Network"))
				{
					Plugin.Log.LogDebug((object)$"{buffer.Data.Length}:{BitConverter.ToString(buffer.Data).Replace('-', ' ')}");
				}
				SteamNetworkingIdentity target = default(SteamNetworkingIdentity);
				foreach (CSteamID peer in _peers)
				{
					if (!(peer == except))
					{
						((SteamNetworkingIdentity)(ref target)).SetSteamID(peer);
						Send(buffer, target, basePacket.DeliveryMask, basePacket.Channel);
					}
				}
			}
			if (handleLocal)
			{
				SteamNetworkingIdentity sender = default(SteamNetworkingIdentity);
				if (SteamManager.Initialized)
				{
					((SteamNetworkingIdentity)(ref sender)).SetSteamID(SteamUser.GetSteamID());
				}
				PacketHandler.HandlePacket(sender, basePacket);
			}
		}

		public void SendSingle(BasePacket basePacket, SteamNetworkingIdentity target)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			Buffer buffer = new Buffer();
			buffer.Write(basePacket.TypeID);
			basePacket.Send(buffer);
			Send(buffer, target, basePacket.DeliveryMask, basePacket.Channel);
		}

		private static void Send(Buffer buffer, SteamNetworkingIdentity target, int flags, Channel channel)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Invalid comparison between Unknown and I4
			//IL_001e: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			if (((SteamNetworkingIdentity)(ref target)).IsInvalid())
			{
				Plugin.Log.LogInfoFiltered("Network", $"Trying to send with an invalid id '{((SteamNetworkingIdentity)(ref target)).GetSteamID().m_SteamID}'");
				Plugin.Log.LogInfoFiltered("Network", Environment.StackTrace);
				return;
			}
			GCHandle gCHandle = GCHandle.Alloc(buffer.Data, GCHandleType.Pinned);
			IntPtr intPtr = gCHandle.AddrOfPinnedObject();
			EResult val = SteamNetworkingMessages.SendMessageToUser(ref target, intPtr, (uint)buffer.WriteHead, flags, (int)channel);
			gCHandle.Free();
			if ((int)val != 1)
			{
				Plugin.Log.LogWarningFiltered("Network", $"SendMessage to {((SteamNetworkingIdentity)(ref target)).GetSteamID().m_SteamID} returned error '{val}'");
			}
		}

		private int GetLastOrderedPackage(int player, Channel channel)
		{
			int value;
			return _lastOrderedPackages.TryGetValue((player, channel), out value) ? value : (-1);
		}

		private void SetLastOrderedPackage(int player, Channel channel, int value)
		{
			_lastOrderedPackages[(player, channel)] = value;
		}

		public BasePacket CreatePacket(PacketId id)
		{
			PacketTypes.TryGetValue(id, out var value);
			return value?.GetConstructor(Type.EmptyTypes)?.Invoke(Array.Empty<object>()) as BasePacket;
		}

		private void HandlePacket(ref SteamNetworkingIdentity sender, Buffer buffer, Dictionary<PacketId, Type> types)
		{
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			PacketId packetId = buffer.ReadPacketId();
			types.TryGetValue(packetId, out var value);
			if (!(value?.GetConstructor(Type.EmptyTypes)?.Invoke(Array.Empty<object>()) is BasePacket basePacket))
			{
				Plugin.Log.LogInfoFiltered("Network", $"Received unknown packet (type: '{packetId}', size: {buffer.Data.Length})");
				return;
			}
			Plugin.Log.LogDebugFiltered("Network", $"Reading packet '{packetId}'");
			basePacket.Receive(buffer);
			if (Ext.LogDebugFiltered("Network"))
			{
				Plugin.Log.LogDebug((object)$"{buffer.Data.Length}:{BitConverter.ToString(buffer.Data).Replace('-', ' ')}");
			}
			if (packetId == PacketId.Combined)
			{
				foreach (BasePacket packet in ((CombinedPacket)basePacket).Packets)
				{
					HandlePacket(ref sender, packet);
				}
				return;
			}
			if (basePacket is LoadoutOpenPacket loadoutOpenPacket)
			{
				Plugin.Log.LogInfo((object)$"[LoadoutDiag] rx LoadoutOpen scene={loadoutOpenPacket.Scene} from={((SteamNetworkingIdentity)(ref sender)).GetSteamID().m_SteamID}");
			}
			HandlePacket(ref sender, basePacket);
		}

		private void HandlePacket(ref SteamNetworkingIdentity sender, BasePacket packet)
		{
			//IL_005f: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			if (packet is BaseOrderedPacket baseOrderedPacket)
			{
				(int, int) order = baseOrderedPacket.GetOrder();
				int lastOrderedPackage = GetLastOrderedPackage(order.Item1, baseOrderedPacket.Channel);
				if (lastOrderedPackage >= order.Item2)
				{
					return;
				}
				SetLastOrderedPackage(order.Item1, baseOrderedPacket.Channel, order.Item2);
			}
			if (packet.CanHandle(((SteamNetworkingIdentity)(ref sender)).GetSteamID()))
			{
				PacketHandler.HandlePacket(sender, packet);
			}
			else
			{
				Plugin.Log.LogInfoFiltered("Network", $"Received unauthorized packet from '{((SteamNetworkingIdentity)(ref sender)).GetSteamID().m_SteamID}' (type: '{packet.TypeID}')");
			}
			if (Server && packet.ShouldPropagate)
			{
				Send(packet, handleLocal: false, ((SteamNetworkingIdentity)(ref sender)).GetSteamID());
			}
		}

		private void OnGameLobbyJoinRequested(GameLobbyJoinRequested_t request)
		{
			//IL_0010: 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_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)
			//IL_0032: 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)
			Plugin.Log.LogInfoFiltered("Network", $"Got lobby join request {request.m_steamIDLobby} : {request.m_steamIDFriend}");
			ConnectLobby(request.m_steamIDLobby, null);
		}

		private void OnLobbyEntered(LobbyEnter_t entered, bool ioFailure)
		{
			//IL_0039: 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_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_0098: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
			if (ioFailure)
			{
				UIManager.LobbyListPanel.CloseConnectingDialog();
				Plugin.Log.LogInfoFiltered("Network", "IO error encountered");
				return;
			}
			if (entered.m_EChatRoomEnterResponse != 1)
			{
				UIManager.LobbyListPanel.CloseConnectingDialog();
				Plugin.Log.LogInfoFiltered("Network", $"Failed to join lobby with code {entered.m_EChatRoomEnterResponse}");
				Local();
				return;
			}
			CSteamID id = new CSteamID(entered.m_ulSteamIDLobby);
			if (SteamMatchmaking.GetLobbyData(id, "password") == "yes" && _password == null)
			{
				UIManager.LobbyListPanel.ShowHideConnectingDialog(show: false);
				UIManager.CreatePasswordDialog(delegate(string password)
				{
					//IL_0020: Unknown result type (might be due to invalid IL or missing references)
					UIManager.LobbyListPanel.ShowHideConnectingDialog(show: true);
					_password = password;
					Connect(id, _password);
				}, CloseLobby);
			}
			else
			{
				Connect(id, _password);
			}
		}

		private void OnSessionRequest(SteamNetworkingMessagesSessionRequest_t request)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_00ca: 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_00e1: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogInfoFiltered("Network", $"Received session request {((SteamNetworkingIdentity)(ref request.m_identityRemote)).GetSteamID().m_SteamID}");
			if (_peers.Count < MaxPlayers)
			{
				Plugin.Log.LogInfoFiltered("Network", "Server Full");
				return;
			}
			CSteamID steamID = ((SteamNetworkingIdentity)(ref request.m_identityRemote)).GetSteamID();
			if (_peers.Contains(steamID))
			{
				SteamNetworkingMessages.AcceptSessionWithUser(ref request.m_identityRemote);
				SyncManager.OnConnected(steamID);
				return;
			}
			if (!Server)
			{
				Plugin.Log.LogInfoFiltered("Network", "Not a Server");
				return;
			}
			bool flag = false;
			int i = 0;
			for (int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(Lobby); i < numLobbyMembers; i++)
			{
				CSteamID lobbyMemberByIndex = SteamMatchmaking.GetLobbyMemberByIndex(Lobby, i);
				if (steamID == lobbyMemberByIndex)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Plugin.Log.LogInfoFiltered("Network", "Not in lobby");
				return;
			}
			Plugin.Log.LogInfoFiltered("Network", $"Accepted {steamID.m_SteamID}");
			_pendingPeers.Add(steamID);
			SteamNetworkingMessages.AcceptSessionWithUser(ref request.m_identityRemote);
		}

		private void OnLobbyChatUpdate(LobbyChatUpdate_t update)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_00e8: 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_00f5: 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: Unknown result type (might be due to invalid IL or missing references)
			if (Online && (update.m_rgfChatMemberStateChange & 1) == 0)
			{
				Plugin.Log.LogInfoFiltered("Network", $"{update.m_ulSteamIDUserChanged} left");
				CSteamID val = default(CSteamID);
				((CSteamID)(ref val))..ctor(update.m_ulSteamIDUserChanged);
				PlayerManager.Player player = Plugin.Instance.PlayerManager.Get(val);
				if (player != null)
				{
					Plugin.Log.LogInfoFiltered("Network", $"Destroying player {player.Id}");
					Plugin.Instance.PlayerManager.Remove(player.Id);
					string friendPersonaName = SteamFriends.GetFriendPersonaName(new CSteamID(update.m_ulSteamIDUserChanged));
					HandleMessage("Server", "Player " + friendPersonaName + " left");
				}
				_peers.Remove(val);
				if (Owner == val)
				{
					MigrateServer();
				}
			}
		}

		private void MigrateServer()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_0092: 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)
			Owner = SteamMatchmaking.GetLobbyOwner(Lobby);
			Plugin.Log.LogInfoFiltered("Network", $"Host disconnected migrating server to {Owner.m_SteamID}");
			if (Owner == SteamUser.GetSteamID())
			{
				HandleMessage("Server", "You are now hosting");
				Server = true;
			}
			else
			{
				HandleMessage("Server", "Host disconnected migrating server to " + SteamFriends.GetFriendPersonaName(Owner));
				Connect(Owner, _password);
			}
			this.OnOwnerChanged?.Invoke(Owner);
		}

		public bool IsServer(CSteamID id)
		{
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			return SteamMatchmaking.GetLobbyOwner(Lobby) == id;
		}
	}
	public enum PacketId
	{
		Approval,
		Disconnect,
		PeerSync,
		SyncPing,
		SyncPong,
		SyncPingInfo,
		SyncLevelData,
		SyncResource,
		SyncPlayer,
		SyncPlayerInput,
		SyncAllyPathfinder,
		SyncEnemyPathfinder,
		SyncPosition,
		SyncHp,
		Combined,
		DayNight,
		EnemySpawn,
		DamageFeedback,
		RequestLevel,
		RestartLevel,
		Resign,
		TeleportPlayer,
		WeaponRequest,
		WeaponResponse,
		BuildOrUpgrade,
		CancelBuild,
		CommandAdd,
		CommandHoldPosition,
		CommandPlace,
		ConfirmBuild,
		ManualAttack,
		Victory,
		LockTarget,
		BossSpawn,
		LoadoutOpen,
		LoadoutSelection,
		LoadoutWeapon,
		LoadoutClose,
		LoadoutStateRequest,
		HostUnlocks
	}
	public static class PacketHandler
	{
		public static bool AwaitingConnectionApproval;

		private static readonly Dictionary<PacketId, Action<SteamNetworkingIdentity, BasePacket>> Handlers = new Dictionary<PacketId, Action<SteamNetworkingIdentity, BasePacket>>
		{
			{
				PacketId.Approval,
				HandleApproval
			},
			{
				PacketId.Disconnect,
				HandleDisconnect
			},
			{
				PacketId.PeerSync,
				HandlePeerList
			},
			{
				PacketId.BossSpawn,
				HandleBossSpawn
			},
			{
				PacketId.LoadoutOpen,
				HandleLoadoutOpen
			},
			{
				PacketId.LoadoutSelection,
				HandleLoadoutSelection
			},
			{
				PacketId.LoadoutWeapon,
				HandleLoadoutWeapon
			},
			{
				PacketId.LoadoutClose,
				HandleLoadoutClose
			},
			{
				PacketId.LoadoutStateRequest,
				HandleLoadoutStateRequest
			},
			{
				PacketId.HostUnlocks,
				HandleHostUnlocks
			},
			{
				PacketId.DamageFeedback,
				HandleDamageFeedback
			},
			{
				PacketId.DayNight,
				HandleDayNight
			},
			{
				PacketId.EnemySpawn,
				HandleEnemySpawn
			},
			{
				PacketId.LockTarget,
				HandleLockTarget
			},
			{
				PacketId.TeleportPlayer,
				HandlePlayerTeleport
			},
			{
				PacketId.Resign,
				HandleResign
			},
			{
				PacketId.Victory,
				HandleVictory
			},
			{
				PacketId.BuildOrUpgrade,
				HandleBuildOrUpgrade
			},
			{
				PacketId.CancelBuild,
				HandleCancelBuild
			},
			{
				PacketId.CommandAdd,
				HandleCommandAdd
			},
			{
				PacketId.CommandPlace,
				HandleCommandPlace
			},
			{
				PacketId.CommandHoldPosition,
				HandleCommandHoldPosition
			},
			{
				PacketId.ConfirmBuild,
				HandleConfirmBuild
			},
			{
				PacketId.ManualAttack,
				HandleManualAttack
			}
		};

		public static void HandlePacket(SteamNetworkingIdentity sender, BasePacket packet)
		{
			//IL_0001: 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)
			Action<SteamNetworkingIdentity, BasePacket> value;
			if (SyncManager.HandlePacket(sender, packet))
			{
				Plugin.Log.LogDebugFiltered("PacketHandler", $"Packet {packet.TypeID} handled by sync");
			}
			else if (Handlers.TryGetValue(packet.TypeID, out value))
			{
				Plugin.Log.LogDebugFiltered("PacketHandler", $"Handling {packet.TypeID} packet");
				value(sender, packet);
			}
			else
			{
				Plugin.Log.LogWarningFiltered("PacketHandler", $"No handler for packet {packet.TypeID}.");
			}
		}

		private static void HandlePeerList(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00b5: 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_0128: Unknown result type (might be due to invalid IL or missing references)
			PeerListPacket peerListPacket = (PeerListPacket)ipacket;
			if (AwaitingConnectionApproval)
			{
				SceneTransitionManager.instance.TransitionFromNullToLevelSelect();
				UIManager.LobbyListPanel.CloseConnectingDialog();
				UIManager.CloseAllPanels();
				AwaitingConnectionApproval = false;
			}
			Plugin.Log.LogInfoFiltered("PacketHandler", "Received player list");
			CSteamID steamID = SteamUser.GetSteamID();
			Plugin.Instance.PlayerManager.LocalId = 0;
			foreach (PeerListPacket.PlayerData player2 in peerListPacket.Players)
			{
				if (player2.SteamId == steamID)
				{
					Plugin.Instance.PlayerManager.LocalId = player2.Id;
				}
				PlayerManager.Player player = Plugin.Instance.PlayerManager.CreateOrGet(player2.SteamId, player2.Id);
				player.SpawnID = player2.SpawnId;
				if (!((Object)(object)player.Object == (Object)null) || Plugin.Instance.PlayerManager.InstantiatePlayer(player, player2.Position))
				{
					((Collider)player.Controller).enabled = false;
					player.Object.transform.position = player2.Position;
					((Collider)player.Controller).enabled = true;
				}
			}
		}

		private static void HandleDayNight(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			//IL_0009: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Invalid comparison between Unknown and I4
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			DayNightPacket dayNightPacket = (DayNightPacket)ipacket;
			if (dayNightPacket.Timestate == DayNightCycle.Instance.CurrentTimestate)
			{
				return;
			}
			if (Plugin.Instance.Network.Server && ((SteamNetworkingIdentity)(ref sender)).GetSteamID() != Network.SteamId)
			{
				Plugin.Instance.Network.Send(dayNightPacket);
			}
			if ((int)dayNightPacket.Timestate == 1)
			{
				NightCallPatch.TriggerNightFall();
				return;
			}
			if ((Object)(object)TagManager.instance != (Object)null && (Object)(object)EnemySpawner.instance != (Object)null)
			{
				EnemySpawner.instance.StopSpawnAfterWaveAndReset();
				foreach (GameObject gameObject in Identifier.GetGameObjects(IdentifierType.Enemy))
				{
					if (!((Object)(object)gameObject == (Object)null))
					{
						Hp component = gameObject.GetComponent<Hp>();
						if (!((Object)(object)component == (Object)null))
						{
							HpPatch.AllowHealthChangeOnClient = true;
							component.TakeDamage(9999f, (TaggedObject)null, true, true);
							HpPatch.AllowHealthChangeOnClient = false;
						}
					}
				}
			}
			Traverse.Create((object)DayNightCycle.Instance).Field<float>("currentNightLength").Value = dayNightPacket.NightLength;
			Traverse val = Traverse.Create((object)DayNightCycle.Instance).Method("SwitchToDayCoroutine", Array.Empty<object>());
			((MonoBehaviour)DayNightCycle.Instance).StartCoroutine(val.GetValue<IEnumerator>());
		}

		private static void HandleEnemySpawn(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			EnemySpawnPacket enemySpawnPacket = (EnemySpawnPacket)ipacket;
			EnemySpawnerPatch.SpawnEnemy(enemySpawnPacket.Wave, enemySpawnPacket.Spawn, enemySpawnPacket.Position, enemySpawnPacket.Id, enemySpawnPacket.Coins, enemySpawnPacket.Elite);
		}

		private static void HandleBossSpawn(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			BossSpawnPacket bossSpawnPacket = (BossSpawnPacket)ipacket;
			Spawn val = BossSpawnRegistry.Resolve(bossSpawnPacket.SpawnRef);
			if (val == null)
			{
				Plugin.Log.LogWarningFiltered("PacketHandler", $"No boss spawn registered for ref {bossSpawnPacket.SpawnRef}");
			}
			else
			{
				EnemySpawnerPatch.SpawnEnemy(val, bossSpawnPacket.DifficultyMulti, bossSpawnPacket.Position, bossSpawnPacket.Id, bossSpawnPacket.Coins, bossSpawnPacket.Elite);
			}
		}

		private static void HandleLoadoutOpen(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			//IL_016a: 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)
			LoadoutOpenPacket loadoutOpenPacket = (LoadoutOpenPacket)ipacket;
			if (!SceneTransitionManagerPatch.InLevelSelect || (Object)(object)UIFrameManager.instance == (Object)null)
			{
				return;
			}
			LevelInteractor[] array = Object.FindObjectsOfType<LevelInteractor>(true);
			Plugin.Log.LogInfo((object)$"[LoadoutDiag] open rx scene={loadoutOpenPacket.Scene} interactors={array.Length}");
			LevelInteractor[] array2 = array;
			foreach (LevelInteractor val in array2)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)val.levelInfo == (Object)null || val.levelInfo.sceneName != loadoutOpenPacket.Scene)
				{
					continue;
				}
				if (!val.CanBePlayed)
				{
					Plugin.Log.LogInfo((object)("LoadoutOpen for locked level '" + loadoutOpenPacket.Scene + "', ignoring"));
					return;
				}
				UIFrameManager instance = UIFrameManager.instance;
				if (LoadoutFrames.IsPopupFrame(instance.ActiveFrame))
				{
					if (!((Object)(object)LevelInteractor.lastActiveLevelInfo == (Object)(object)val.levelInfo))
					{
						LevelInteractor.lastActiveLevelInfo = val.levelInfo;
						LoadoutState.SuppressNextDiff = true;
						LoadoutFrames.CloseAllPopupFrames();
						UIFrameManager.ForceOpenLevelSelect();
						OpenRemoteLoadoutGrid();
						if (Plugin.Instance.Network.Server)
						{
							Plugin.Instance.Network.Send(new LoadoutOpenPacket
							{
								Scene = loadoutOpenPacket.Scene
							});
						}
					}
				}
				else
				{
					LoadoutState.RemoteOpenPending = true;
					LevelInteractor.lastActiveLevelInfo = val.levelInfo;
					UIFrameManager.ForceOpenLevelSelect();
					if (!LoadoutFrames.PopupOpen)
					{
						LoadoutState.RemoteOpenPending = false;
					}
					else
					{
						OpenRemoteLoadoutGrid();
					}
				}
				return;
			}
			Plugin.Log.LogInfo((object)("LoadoutOpen for unknown level '" + loadoutOpenPacket.Scene + "', ignoring"));
		}

		private static void OpenRemoteLoadoutGrid()
		{
			UIFrame gridFrame = LoadoutFrames.GridFrame;
			if (!((Object)(object)gridFrame == (Object)null) && !((Object)(object)UIFrameManager.instance.ActiveFrame == (Object)(object)gridFrame))
			{
				LoadoutState.SuppressNextDiff = true;
				UIFrameManager.instance.ChangeActiveFrame(gridFrame);
			}
		}

		private static void HandleLoadoutSelection(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			LoadoutSelectionPacket loadoutSelectionPacket = (LoadoutSelectionPacket)ipacket;
			if ((Object)(object)PerkManager.instance == (Object)null || !SceneTransitionManagerPatch.InLevelSelect || !LoadoutFrames.PopupOpen)
			{
				return;
			}
			List<Equippable> currentlyEquipped = PerkManager.instance.CurrentlyEquipped;
			for (int num = currentlyEquipped.Count - 1; num >= 0; num--)
			{
				if (!Equip.Weapons.Contains(Equip.Convert(((Object)currentlyEquipped[num]).name)))
				{
					currentlyEquipped.RemoveAt(num);
				}
			}
			List<Equipment> list = new List<Equipment>();
			foreach (Equipment item in loadoutSelectionPacket.Selection)
			{
				if (item != Equipment.Invalid && !Equip.Weapons.Contains(item) && !((Object)(object)Equip.Convert(item) == (Object)null))
				{
					Equip.EquipEquipment(item);
					list.Add(item);
				}
			}
			LoadoutState.SuppressNextDiff = true;
			UIFrame val = (((Object)(object)UIFrameManager.instance != (Object)null) ? UIFrameManager.instance.ActiveFrame : null);
			LoadoutUIHelper val2 = LoadoutFrames.HelperFor(val);
			if ((Object)(object)val2 != (Object)null)
			{
				val2.OnShow();
				val.RefetchManagedElements();
				List<Equipment> first = CaptureNonWeaponSelection();
				list.Sort();
				if (!first.SequenceEqual(list))
				{
					LoadoutState.SuppressNextDiff = false;
				}
			}
		}

		private static List<Equipment> CaptureNonWeaponSelection()
		{
			List<Equipment> list = new List<Equipment>();
			foreach (Equippable item in PerkManager.instance.CurrentlyEquipped)
			{
				Equipment equipment = Equip.Convert(((Object)item).name);
				if (equipment != Equipment.Invalid && !Equip.Weapons.Contains(equipment))
				{
					list.Add(equipment);
				}
			}
			list.Sort();
			return list;
		}

		private static void HandleLoadoutWeapon(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			LoadoutWeaponPacket loadoutWeaponPacket = (LoadoutWeaponPacket)ipacket;
			if (loadoutWeaponPacket.PlayerId != Plugin.Instance.PlayerManager.LocalId)
			{
				LoadoutState.WeaponPicks[loadoutWeaponPacket.PlayerId] = loadoutWeaponPacket.Weapon;
			}
		}

		private static void HandleLoadoutStateRequest(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			//IL_0062: 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_0087: 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 (!Plugin.Instance.Network.Server || !LoadoutFrames.PopupOpen || (Object)(object)LevelInteractor.lastActiveLevelInfo == (Object)null)
			{
				return;
			}
			Plugin.Log.LogInfo((object)"[LoadoutDiag] replaying loadout state to a late peer");
			Network network = Plugin.Instance.Network;
			network.SendSingle(new LoadoutOpenPacket
			{
				Scene = LevelInteractor.lastActiveLevelInfo.sceneName
			}, sender);
			network.SendSingle(BuildHostUnlocksPacket(), sender);
			network.SendSingle(new LoadoutSelectionPacket
			{
				Selection = CaptureNonWeaponSelection()
			}, sender);
			foreach (KeyValuePair<ushort, Equipment> weaponPick in LoadoutState.WeaponPicks)
			{
				network.SendSingle(new LoadoutWeaponPacket
				{
					PlayerId = weaponPick.Key,
					Weapon = weaponPick.Value
				}, sender);
			}
		}

		internal static HostUnlocksPacket BuildHostUnlocksPacket()
		{
			HostUnlocksPacket hostUnlocksPacket = new HostUnlocksPacket();
			if ((Object)(object)PerkManager.instance == (Object)null)
			{
				return hostUnlocksPacket;
			}
			foreach (Equippable allEquippable in PerkManager.instance.allEquippables)
			{
				if (allEquippable.IsUnlocked)
				{
					Equipment equipment = Equip.Convert(((Object)allEquippable).name);
					if (equipment != Equipment.Invalid)
					{
						hostUnlocksPacket.Unlocks.Add(equipment);
					}
				}
			}
			return hostUnlocksPacket;
		}

		private static void HandleHostUnlocks(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.Instance.Network.IsServer(((SteamNetworkingIdentity)(ref sender)).GetSteamID()))
			{
				return;
			}
			HostUnlocksPacket hostUnlocksPacket = (HostUnlocksPacket)ipacket;
			HostUnlocks.Session.Clear();
			foreach (Equipment unlock in hostUnlocksPacket.Unlocks)
			{
				if (unlock != Equipment.Invalid)
				{
					HostUnlocks.Session.Add(unlock);
				}
			}
			if (LoadoutFrames.PopupOpen && (Object)(object)UIFrameManager.instance != (Object)null)
			{
				LoadoutUIHelper obj = LoadoutFrames.HelperFor(UIFrameManager.instance.ActiveFrame);
				if (obj != null)
				{
					obj.OnShow();
				}
			}
		}

		private static void HandleLoadoutClose(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			if (SceneTransitionManagerPatch.InLevelSelect && !((Object)(object)UIFrameManager.instance == (Object)null))
			{
				if (LoadoutFrames.IsPopupFrame(UIFrameManager.instance.ActiveFrame))
				{
					LoadoutState.RemoteClosePending = true;
					LoadoutState.SuppressNextDiff = true;
					LoadoutFrames.CloseAllPopupFrames();
				}
				LoadoutState.WeaponPicks.Clear();
			}
		}

		private static void HandlePlayerTeleport(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			TeleportPlayerPacket teleportPlayerPacket = (TeleportPlayerPacket)ipacket;
			PlayerManager.Player player = Plugin.Instance.PlayerManager.Get((int)teleportPlayerPacket.PlayerId);
			if (!((Object)(object)player.Object == (Object)null))
			{
				((Collider)player.Controller).enabled = false;
				player.Object.transform.position = teleportPlayerPacket.Position;
				((Collider)player.Controller).enabled = true;
			}
		}

		private static void HandleResign(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			try
			{
				Plugin.Log.LogDebug((object)"Resign");
				UIFrameManager.instance.CloseAllFrames();
				LocalGamestate.Instance.SetState((State)3, false, true);
			}
			catch
			{
				Plugin.Log.LogError((object)"InGameResignUIHelper: Bro we can not resign here.");
			}
		}

		private static void HandleVictory(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			try
			{
				Plugin.Log.LogDebug((object)"Victory");
				UIFrameManager.instance.CloseAllFrames();
				LocalGamestate.Instance.SetState((State)2, false, true);
			}
			catch
			{
				Plugin.Log.LogError((object)"Could not transition to victory state.");
			}
		}

		private static void HandleCommandAdd(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			CommandAddPacket commandAddPacket = (CommandAddPacket)ipacket;
			PlayerManager.Player player = Plugin.Instance.PlayerManager.Get((int)commandAddPacket.Player);
			if ((Object)(object)player.Object == (Object)null)
			{
				return;
			}
			CommandUnits component = player.Object.GetComponent<CommandUnits>();
			foreach (IdentifierData unit in commandAddPacket.Units)
			{
				GameObject obj = unit.Get();
				PathfindMovementPlayerunit val = ((obj != null) ? obj.GetComponent<PathfindMovementPlayerunit>() : null);
				if ((Object)(object)val != (Object)null)
				{
					CommandUnitsPatch.AddUnit(component, val);
				}
			}
		}

		private static void HandleCommandPlace(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			CommandPlacePacket commandPlacePacket = (CommandPlacePacket)ipacket;
			PlayerManager.Player player = Plugin.Instance.PlayerManager.Get((int)commandPlacePacket.Player);
			if ((Object)(object)player.Object == (Object)null)
			{
				return;
			}
			CommandUnits component = player.Object.GetComponent<CommandUnits>();
			CommandUnitsPatch.EmitWaypoint(component, commandPlacePacket.Units.Count > 0);
			foreach (CommandPlacePacket.UnitData unit2 in commandPlacePacket.Units)
			{
				IdentifierData unit = unit2.Unit;
				GameObject obj = unit.Get();
				PathfindMovementPlayerunit val = ((obj != null) ? obj.GetComponent<PathfindMovementPlayerunit>() : null);
				if ((Object)(object)val != (Object)null)
				{
					CommandUnitsPatch.PlaceUnit(component, val, unit2.Home);
				}
			}
		}

		private static void HandleCommandHoldPosition(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			CommandHoldPositionPacket commandHoldPositionPacket = (CommandHoldPositionPacket)ipacket;
			PlayerManager.Player player = Plugin.Instance.PlayerManager.Get((int)commandHoldPositionPacket.Player);
			if ((Object)(object)player?.Object == (Object)null)
			{
				return;
			}
			CommandUnits component = player.Object.GetComponent<CommandUnits>();
			if (commandHoldPositionPacket.Units.Count > 0)
			{
				CommandUnitsPatch.PlayHoldSound(component);
			}
			foreach (CommandHoldPositionPacket.UnitData unit2 in commandHoldPositionPacket.Units)
			{
				IdentifierData unit = unit2.Unit;
				GameObject obj = unit.Get();
				PathfindMovementPlayerunit val = ((obj != null) ? obj.GetComponent<PathfindMovementPlayerunit>() : null);
				if ((Object)(object)val != (Object)null)
				{
					CommandUnitsPatch.HoldPosition(val, unit2.Home);
				}
			}
		}

		private static void HandleManualAttack(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			ManualAttackPacket manualAttackPacket = (ManualAttackPacket)ipacket;
			GameObject val = Plugin.Instance.PlayerManager.Get((int)manualAttackPacket.Player)?.Object;
			if (!((Object)(object)val == (Object)null))
			{
				ManualAttack manualAttack = val.GetComponent<PlayerInteraction>().ManualAttack;
				manualAttack.TryToAttack();
			}
		}

		private static void HandleLockTarget(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			LockTargetPacket lockTargetPacket = (LockTargetPacket)ipacket;
			if (lockTargetPacket.PlayerId == Plugin.Instance.PlayerManager.LocalId)
			{
				return;
			}
			GameObject val = Plugin.Instance.PlayerManager.Get((int)lockTargetPacket.PlayerId)?.Object;
			if (!((Object)(object)val == (Object)null))
			{
				ManualAttack manualAttack = val.GetComponent<PlayerInteraction>().ManualAttack;
				if (!((Object)(object)manualAttack == (Object)null))
				{
					GameObject obj = lockTargetPacket.Target.Get();
					TaggedObject val2 = ((obj != null) ? obj.GetComponent<TaggedObject>() : null);
					Traverse val3 = Traverse.Create((object)manualAttack);
					val3.Field<TaggedObject>("preferredTarget").Value = val2;
					val3.Field<bool>("preferredTargetPreviouslySet").Value = (Object)(object)val2 != (Object)null;
				}
			}
		}

		private static void HandleApproval(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			//IL_006e: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			ApprovalPacket approvalPacket = (ApprovalPacket)ipacket;
			Plugin.Log.LogInfoFiltered("PacketHandler", $"Handling approval of {((SteamNetworkingIdentity)(ref sender)).GetSteamID64()}");
			if (!approvalPacket.SameVersion)
			{
				Plugin.Log.LogInfoFiltered("PacketHandler", $"{((SteamNetworkingIdentity)(ref sender)).GetSteamID64()} has wrong version");
				Plugin.Instance.Network.KickPeer(((SteamNetworkingIdentity)(ref sender)).GetSteamID(), DisconnectPacket.Reason.WrongVersion);
			}
			else if (Plugin.Instance.Network.Authenticate(approvalPacket.Password))
			{
				Plugin.Log.LogInfoFiltered("PacketHandler", $"{((SteamNetworkingIdentity)(ref sender)).GetSteamID64()} Authenticated");
				Plugin.Instance.Network.AddPlayer(((SteamNetworkingIdentity)(ref sender)).GetSteamID());
			}
			else
			{
				Plugin.Log.LogInfoFiltered("PacketHandler", $"Authentication of {((SteamNetworkingIdentity)(ref sender)).GetSteamID64()} failed");
				Plugin.Instance.Network.KickPeer(((SteamNetworkingIdentity)(ref sender)).GetSteamID(), DisconnectPacket.Reason.WrongPassword);
			}
		}

		private static void HandleDisconnect(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			DisconnectPacket disconnectPacket = (DisconnectPacket)ipacket;
			AwaitingConnectionApproval = false;
			Plugin.Log.LogInfoFiltered("PacketHandler", $"Disconnected with reason {disconnectPacket.DisconnectReason}");
			string message = disconnectPacket.DisconnectReason switch
			{
				DisconnectPacket.Reason.Kicked => "You were kicked!", 
				DisconnectPacket.Reason.WrongPassword => "You gave the wrong password.", 
				DisconnectPacket.Reason.WrongVersion => "Different multiplayer mod version.", 
				_ => "Unknown", 
			};
			UIManager.LobbyListPanel.CloseConnectingDialog();
			UIManager.CreateMessageDialog("Disconnected", message);
		}

		private static void HandleBuildOrUpgrade(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.Instance.Network.Server)
			{
				BuildOrUpgradePacket buildOrUpgradePacket = (BuildOrUpgradePacket)ipacket;
				BuildSlotPatch.UpgradeInfo upgradeInfo = BuildSlotPatch.GetUpgradeInfo(buildOrUpgradePacket.BuildingId, buildOrUpgradePacket.Level, buildOrUpgradePacket.Choice);
				if (GlobalData.Balance < upgradeInfo.Cost || upgradeInfo.CurrentLevel > buildOrUpgradePacket.Level)
				{
					Plugin.Log.LogInfoFiltered("PacketHandler", $"Cancel building {buildOrUpgradePacket.BuildingId}:{buildOrUpgradePacket.Level}:{buildOrUpgradePacket.Choice} for {upgradeInfo.Cost}");
					Plugin.Instance.Network.SendSingle(new CancelBuildPacket
					{
						BuildingId = buildOrUpgradePacket.BuildingId
					}, sender);
				}
				else
				{
					Plugin.Log.LogInfoFiltered("PacketHandler", $"Confirmed building {buildOrUpgradePacket.BuildingId}:{buildOrUpgradePacket.Level}:{buildOrUpgradePacket.Choice} for {upgradeInfo.Cost}");
					Plugin.Instance.Network.Send(new ConfirmBuildPacket
					{
						BuildingId = buildOrUpgradePacket.BuildingId,
						Level = buildOrUpgradePacket.Level,
						Choice = buildOrUpgradePacket.Choice,
						PlayerID = Plugin.Instance.PlayerManager.Get(((SteamNetworkingIdentity)(ref sender)).GetSteamID()).Id
					}, handleLocal: true);
					GlobalData.Balance -= upgradeInfo.Cost;
				}
			}
		}

		private static void HandleCancelBuild(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			CancelBuildPacket cancelBuildPacket = (CancelBuildPacket)ipacket;
			Plugin.Log.LogInfoFiltered("PacketHandler", $"Local build of {cancelBuildPacket.BuildingId} cancelled");
			BuildSlotPatch.CancelBuild(cancelBuildPacket.BuildingId);
			GlobalData.LocalBalanceDelta = 0;
		}

		private static void HandleConfirmBuild(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			ConfirmBuildPacket confirmBuildPacket = (ConfirmBuildPacket)ipacket;
			if (confirmBuildPacket.PlayerID == Plugin.Instance.PlayerManager.LocalPlayer.Id)
			{
				Plugin.Log.LogInfoFiltered("PacketHandler", $"Local build of {confirmBuildPacket.BuildingId}:{confirmBuildPacket.Level}:{confirmBuildPacket.Choice} confirmed");
				GlobalData.LocalBalanceDelta = 0;
			}
			else
			{
				Plugin.Log.LogInfoFiltered("PacketHandler", $"Building {confirmBuildPacket.BuildingId}:{confirmBuildPacket.Level}:{confirmBuildPacket.Choice}");
			}
			HpPatch.AllowHealthChangeOnClient = true;
			BuildSlotPatch.HandleUpgrade(confirmBuildPacket.PlayerID, confirmBuildPacket.BuildingId, confirmBuildPacket.Level, confirmBuildPacket.Choice);
			HpPatch.AllowHealthChangeOnClient = false;
		}

		private static void HandleDamageFeedback(SteamNetworkingIdentity sender, BasePacket ipacket)
		{
			DamageFeedbackPacket damageFeedbackPacket = (DamageFeedbackPacket)ipacket;
			GameObject val = damageFeedbackPacket.Target.Get();
			if (!((Object)(object)val == (Object)null))
			{
				Hp component = val.GetComponent<Hp>();
				component.OnReceiveDamage?.Invoke(damageFeedbackPacket.CausedByPlayer);
			}
		}
	}
	public class PlayerManager
	{
		public delegate void PlayerDelegate(Player player);

		public class Player
		{
			private uint _ping;

			public ushort Id;

			public CSteamID SteamID;

			public byte SpawnID;

			public GameObject Object;

			public PlayerNetworkData Data;

			public readonly PlayerNetworkData.Shared Shared = new PlayerNetworkData.Shared();

			public CharacterController Controller;

			public Equipment Weapon = Equipment.LongBow;

			public uint Ping
			{
				get
				{
					return _ping;
				}
				set
				{
					_ping = value;
					Plugin.Instance.PlayerManager.OnPlayerPingUpdated?.Invoke(this);
				}
			}

			public Vector3 SpawnLocation => Helpers.GetSpawnLocation(Plugin.Instance.PlayerManager.SpawnLocation, SpawnID);
		}

		private ushort _localId;

		private Dictionary<int, Player> _players = new Dictionary<int, Player>();

		private Dictionary<CSteamID, Player> _steamToPlayer = new Dictionary<CSteamID, Player>();

		private GameObject _playerContainer;

		private GameObject _playerPrefab;

		private Vector3 _spawn;

		public ushort LocalId
		{
			get
			{
				return _localId;
			}
			set
			{
				_localId = value;
				Plugin.Log.LogInfoFiltered("Network", $"Local player set to {value}");
			}
		}

		public Player LocalPlayer
		{
			get
			{
				Player value;
				return _players.TryGetValue(LocalId, out value) ? value : null;
			}
		}

		public Vector3 SpawnLocation
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _spawn;
			}
			set
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: 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)
				_spawn = value;
				foreach (KeyValuePair<int, Player> player in _players)
				{
					if ((Object)(object)player.Value.Object != (Object)null)
					{
						player.Value.Object.transform.position = Helpers.GetSpawnLocation(_spawn, player.Value.SpawnID);
					}
				}
			}
		}

		public event PlayerDelegate OnPlayerAdded;

		public event PlayerDelegate OnPlayerInstantiated;

		public event PlayerDelegate OnPlayerRemoved;

		public event PlayerDelegate OnPlayerPingUpdated;

		public ushort GenerateID()
		{
			ushort num;
			do
			{
				num = (ushort)Random.Range(0, 65535);
			}
			while (_players.ContainsKey(num));
			return num;
		}

		public Player CreateOrGet(CSteamID steamId, ushort id)
		{
			//IL_0089: 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_0045: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			if (!_players.TryGetValue(id, out var value))
			{
				Plugin.Log.LogInfo((object)$"Creating player {steamId}:{id}");
				value = new Player
				{
					Id = id,
					SteamID = steamId
				};
				_players[id] = value;
				_steamToPlayer[steamId] = value;
				this.OnPlayerAdded?.Invoke(value);
			}
			else
			{
				Plugin.Log.LogInfo((object)$"Updating Player {steamId}:{id}");
			}
			return value;
		}

		public void Remove(int player)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			if (_players.ContainsKey(player))
			{
				Player player2 = _players[player];
				this.OnPlayerRemoved?.Invoke(player2);
				Plugin.Log.LogInfo((object)$"Destroying player {player2.SteamID}:{player}");
				Object.Destroy((Object)(object)player2.Object);
				_steamToPlayer.Remove(player2.SteamID);
				_players.Remove(player);
			}
		}

		public bool InstantiatePlayer(Player player, Vector3 position)
		{
			//IL_0045: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			if ((Object)(object)_playerPrefab == (Object)null)
			{
				return false;
			}
			if ((Object)(object)player.Object != (Object)null)
			{
				Object.Destroy((Object)(object)player.Object);
			}
			Plugin.Log.LogInfo((object)$"Instantiating player {player.SteamID}:{player.Id} at {Helpers.GetSpawnLocation(_spawn, player.SpawnID)}");
			player.Object = Object.Instantiate<GameObject>(_playerPrefab, _playerContainer.transform);
			player.Controller = player.Object.GetComponent<CharacterController>();
			player.Data = player.Object.GetComponent<PlayerNetworkData>();
			player.Data.Player = player;
			player.Data.SharedData = player.Shared;
			player.Data.id = player.Id;
			Identifier component = player.Object.GetComponent<Identifier>();
			component.SetIdentity(IdentifierType.Player, player.Id);
			player.Object.transform.position = position;
			player.Object.SetActive(true);
			if (player.Id == LocalId)
			{
				PlayerMovement component2 = player.Object.GetComponent<PlayerMovement>();
				if ((Object)(object)component2 != (Object)null)
				{
					PlayerMovement.instance = component2;
				}
			}
			GameObject val = new GameObject($"player_{player.Id}_label");
			val.SetActive(false);
			val.AddComponent<TextMeshPro>();
			PlayerLabelFollower playerLabelFollower = val.AddComponent<PlayerLabelFollower>();
			playerLabelFollower.TargetPlayer = player.Id;
			val.SetActive(true);
			this.OnPlayerInstantiated?.Invoke(player);
			return true;
		}

		public Player Get(int id)
		{
			Player value;
			return _players.TryGetValue(id, out value) ? value : null;
		}

		public Player Get(CSteamID id)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Player value;
			return _steamToPlayer.TryGetValue(id, out value) ? value : null;
		}

		public IEnumerable<Player> GetAllPlayers()
		{
			return _players.Select((KeyValuePair<int, Player> p) => p.Value);
		}

		public IEnumerable<PlayerNetworkData> GetAllPlayerData()
		{
			return _players.Select((KeyValuePair<int, Player> p) => p.Value.Data);
		}

		public void SetPrefab(GameObject prefab)
		{
			//IL_009a: 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)
			if ((Object)(object)_playerPrefab != (Object)null)
			{
				Object.Destroy((Object)(object)_playerPrefab);
				_playerPrefab = null;
			}
			if ((Object)(object)prefab == (Object)null)
			{
				return;
			}
			_playerContainer = ((Component)prefab.transform.parent).gameObject;
			_playerPrefab = Helpers.InstantiateDisabled<GameObject>(prefab, ((Component)Plugin.Instance).transform, worldPositionStays: true);
			PlayerNetworkData playerNetworkData = _playerPrefab.AddComponent<PlayerNetworkData>();
			playerNetworkData.id = 0;
			_playerPrefab.AddComponent<Identifier>();
			Plugin.Log.LogInfo((object)"Initialized player prefab");
			SpawnLocation = prefab.transform.position;
			foreach (KeyValuePair<int, Player> player in _players)
			{
				InstantiatePlayer(player.Value, player.Value.SpawnLocation);
			}
		}

		public void Clear()
		{
			foreach (KeyValuePair<int, Player> player in _players)
			{
				Object.Destroy((Object)(object)player.Value.Object);
			}
			_players.Clear();
			_steamToPlayer.Clear();
		}
	}
}
namespace ThronefallMP.Network.Sync
{
	public class AllyPathfinderSync : BaseTargetSync
	{
		protected override float MinWaitTimer => 0.1f;

		protected override IEnumerable<(IdentifierData id, GameObject target)> Targets()
		{
			foreach (var data in Identifier.GetIdentifiers(IdentifierType.Ally))
			{
				if (!((Object)(object)data.target == (Object)null) && !((Object)(object)data.target.GetComponent<PathfindMovementPlayerunit>() == (Object)null))
				{
					IdentifierData item = new IdentifierData
					{
						Type = IdentifierType.Ally
					};
					(item.Id, _) = data;
					yield return (id: item, target: data.target);
				}
			}
		}

		protected override BasePacket CreateSyncPacket(CSteamID peer, IdentifierData id, GameObject target)
		{
			//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)
			PathfindMovementPlayerunit component = target.GetComponent<PathfindMovementPlayerunit>();
			Traverse<int> val = Traverse.Create((object)component).Field<int>("nextPathPointIndex");
			Traverse<List<Vector3>> val2 = Traverse.Create((object)component).Field<List<Vector3>>("path");
			Traverse<bool> val3 = Traverse.Create((object)component).Field<bool>("followingPlayer");
			Traverse<TaggedObject> val4 = Traverse.Create((object)component).Field<TaggedObject>("seekToTaggedObj");
			IdentifierData targetObject = IdentifierData.Invalid;
			if ((Object)(object)val4.Value != (Object)null)
			{
				targetObject = new IdentifierData(((Component)val4.Value).GetComponent<Identifier>());
			}
			else if (val3.Value)
			{
				targetObject = new IdentifierData
				{
					Type = IdentifierType.Player
				};
			}
			return new SyncAllyPathfinderPacket
			{
				Ally = id.Id,
				TargetObject = targetObject,
				HomePosition = component.HomePosition,
				HasReachedHomePositionAlready = component.HasReachedHomePositionAlready,
				Slowed = ((PathfindMovement)component).IsSlowed,
				PathIndex = (ushort)val.Value,
				Path = val2.Value
			};
		}

		protected override bool Compare(CSteamID peer, IdentifierData id, GameObject target, BasePacket current, BasePacket last)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			SyncAllyPathfinderPacket syncAllyPathfinderPacket = (SyncAllyPathfinderPacket)current;
			SyncAllyPathfinderPacket syncAllyPathfinderPacket2 = (SyncAllyPathfinderPacket)last;
			if (syncAllyPathfinderPacket.Path.Count != syncAllyPathfinderPacket2.Path.Count)
			{
				return false;
			}
			Vector3 val;
			for (int i = 0; i < syncAllyPathfinderPacket.Path.Count; i++)
			{
				val = syncAllyPathfinderPacket.Path[i] - syncAllyPathfinderPacket2.Path[i];
				if (((Vector3)(ref val)).sqrMagnitude > 0.0025f)
				{
					return false;
				}
			}
			int result;
			if (syncAllyPathfinderPacket.TargetObject.Type == syncAllyPathfinderPacket2.TargetObject.Type && syncAllyPathfinderPacket.TargetObject.Id == syncAllyPathfinderPacket2.TargetObject.Id)
			{
				val = syncAllyPathfinderPacket.HomePosition - syncAllyPathfinderPacket2.HomePosition;
				if (((Vector3)(ref val)).sqrMagnitude < 0.0025f && syncAllyPathfinderPacket.HasReachedHomePositionAlready == syncAllyPathfinderPacket2.HasReachedHomePositionAlready)
				{
					result = ((syncAllyPathfinderPacket.Slowed == syncAllyPathfinderPacket2.Slowed) ? 1 : 0);
					goto IL_0107;
				}
			}
			result = 0;
			goto IL_0107;
			IL_0107:
			return (byte)result != 0;
		}

		public override bool CanHandle(BasePacket packet)
		{
			return packet.TypeID == PacketId.SyncAllyPathfinder;
		}

		public override void Handle(CSteamID peer, BasePacket packet)
		{
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			SyncAllyPathfinderPacket syncAllyPathfinderPacket = (SyncAllyPathfinderPacket)packet;
			GameObject gameObject = Identifier.GetGameObject(IdentifierType.Ally, syncAllyPathfinderPacket.Ally);
			if ((Object)(object)gameObject == (Object)null)
			{
				Plugin.Log.LogInfoFiltered("PathfindingAllySync", $"Ally {syncAllyPathfinderPacket.Ally} not found, discarding");
				return;
			}
			PathfindMovementPlayerunit component = gameObject.GetComponent<PathfindMovementPlayerunit>();
			Traverse<Vector3> val = Traverse.Create((object)component).Field<Vector3>("seekToTargetPos");
			Traverse<bool> val2 = Traverse.Create((object)component).Field<bool>("currentlyWalkingHome");
			Traverse<bool> val3 = Traverse.Create((object)component).Field<bool>("hasReachedHomePositionAlready");
			Traverse<bool> val4 = Traverse.Create((object)component).Field<bool>("followingPlayer");
			Traverse<float> val5 = Traverse.Create((object)component).Field<float>("slowedFor");
			Traverse<int> val6 = Traverse.Create((object)component).Field<int>("nextPathPointIndex");
			Traverse<List<Vector3>> val7 = Traverse.Create((object)component).Field<List<Vector3>>("path");
			Traverse<TaggedObject> val8 = Traverse.Create((object)component).Field<TaggedObject>("seekToTaggedObj");
			GameObject val9 = syncAllyPathfinderPacket.TargetObject.Get();
			bool flag = syncAllyPathfinderPacket.TargetObject.Type == IdentifierType.Invalid;
			component.HomePosition = syncAllyPathfinderPacket.HomePosition;
			val4.Value = syncAllyPathfinderPacket.TargetObject.Type == IdentifierType.Player;
			val.Value = ((val4.Value || val2.Value || (Object)(object)val9 == (Object)null) ? component.HomePosition : val9.transform.position);
			val8.Value = ((flag || syncAllyPathfinderPacket.TargetObject.Type == IdentifierType.Player) ? null : val9.GetComponent<TaggedObject>());
			val2.Value = flag;
			val3.Value = syncAllyPathfinderPacket.HasReachedHomePositionAlready;
			val5.Value = (syncAllyPathfinderPacket.Slowed ? float.MaxValue : float.MinValue);
			val6.Value = syncAllyPathfinderPacket.PathIndex;
			val7.Value = syncAllyPathfinderPacket.Path;
		}
	}
	public abstract class BaseSync
	{
		private class State
		{
			public BasePacket LastPacket;

			public float ForceTimer;

			public float MinWaitTimer;
		}

		private readonly Dictionary<CSteamID, State> _states = new Dictionary<CSteamID, State>();

		private readonly State _state = new State();

		protected virtual bool CaresAboutPeer => false;

		protected virtual float ForceUpdateTimer => float.MaxValue;

		protected virtual float MinWaitTimer => 0f;

		protected virtual bool ShouldUpdate => Plugin.Instance.Network.Server;

		protected BaseSync()
		{
			SyncManager.RegisterSync(this);
		}

		protected abstract BasePacket CreateSyncPacket(CSteamID peer);

		protected abstract bool Compare(CSteamID peer, BasePacket current, BasePacket last);

		protected abstract void HandlePacket(CSteamID peer, BasePacket packet);

		public abstract bool CanHandle(BasePacket packet);

		public void Handle(CSteamID peer, BasePacket packet)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			HandlePacket(peer, packet);
			foreach (KeyValuePair<CSteamID, State> state in _states)
			{
				state.Value.LastPacket = packet;
			}
		}

		private BasePacket PacketToSend(State state, CSteamID peer)
		{
			//IL_003d: 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)
			state.ForceTimer += Time.deltaTime;
			state.MinWaitTimer += Time.deltaTime;
			if (state.MinWaitTimer < MinWaitTimer)
			{
				return null;
			}
			BasePacket basePacket = CreateSyncPacket(peer);
			if (state.ForceTimer < ForceUpdateTimer && state.LastPacket != null && Compare(peer, basePacket, state.LastPacket))
			{
				state.LastPacket = basePacket;
				return null;
			}
			state.LastPacket = basePacket;
			state.LastPacket = basePacket;
			state.ForceTimer = 0f;
			state.MinWaitTimer = 0f;
			return basePacket;
		}

		public void Update()
		{
			//IL_00d3: 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_00fa: 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_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_0051: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldUpdate)
			{
				return;
			}
			if (CaresAboutPeer)
			{
				SteamNetworkingIdentity target = default(SteamNetworkingIdentity);
				{
					foreach (CSteamID peer in Plugin.Instance.Network.Peers)
					{
						if (!_states.TryGetValue(peer, out var value))
						{
							value = new State();
							_states[peer] = value;
						}
						BasePacket basePacket = PacketToSend(value, peer);
						if (basePacket != null)
						{
							((SteamNetworkingIdentity)(ref target)).SetSteamID(peer);
							Plugin.Instance.Network.SendSingle(basePacket, target);
						}
					}
					return;
				}
			}
			BasePacket basePacket2 = PacketToSend(_state, CSteamID.Nil);
			if (basePacket2 != null)
			{
				Plugin.Instance.Network.Send(basePacket2);
			}
		}

		public void Reset()
		{
			_states.Clear();
		}

		public void OnConnected(CSteamID id)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			State state = (CaresAboutPeer ? GeneralExtensions.GetValueSafe<CSteamID, State>(_states, id) : _state);
			if (state != null)
			{
				state.ForceTimer = 0f;
				state.MinWaitTimer = 0f;
				state.LastPacket = null;
			}
		}
	}
	public abstract class BaseTargetSync
	{
		private class State
		{
			public BasePacket LastPacket;

			public float ForceTimer;

			public float MinWaitTimer;
		}

		private const int CombineThreshold = 10;

		private readonly Dictionary<(CSteamID, IdentifierData), State> _states = new Dictionary<(CSteamID, IdentifierData), State>();

		protected virtual bool HandleDisabledTargets => false;

		protected virtual bool CaresAboutPeer => false;

		protected virtual float ForceUpdateTimer => float.MaxValue;

		protected virtual float MinWaitTimer => 0f;

		protected virtual bool ShouldUpdate => Plugin.Instance.Network.Server;

		protected BaseTargetSync()
		{
			SyncManager.RegisterSync(this);
		}

		protected abstract IEnumerable<(IdentifierData id, GameObject target)> Targets();

		protected abstract BasePacket CreateSyncPacket(CSteamID peer, IdentifierData id, GameObject target);

		protected abstract bool Compare(CSteamID peer, IdentifierData id, GameObject target, BasePacket current, BasePacket last);

		public abstract bool CanHandle(BasePacket packet);

		public abstract void Handle(CSteamID peer, BasePacket packet);

		protected virtual bool Filter(CSteamID peer, IdentifierData id, GameObject target)
		{
			return false;
		}

		private BasePacket PacketToSend(State state, CSteamID peer, IdentifierData id, GameObject target)
		{
			//IL_003d: 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)
			state.ForceTimer += Time.deltaTime;
			state.MinWaitTimer += Time.deltaTime;
			if (state.MinWaitTimer < MinWaitTimer)
			{
				return null;
			}
			BasePacket basePacket = CreateSyncPacket(peer, id, target);
			if (state.ForceTimer < ForceUpdateTimer && state.LastPacket != null && Compare(peer, id, target, basePacket, state.LastPacket))
			{
				return null;
			}
			state.LastPacket = basePacket;
			state.ForceTimer = 0f;
			state.MinWaitTimer = 0f;
			return basePacket;
		}

		public void Update()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: 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_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: 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_00d5: 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_03a7: 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_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: 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_03d9: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldUpdate)
			{
				return;
			}
			Dictionary<CSteamID, List<BasePacket>> dictionary = new Dictionary<CSteamID, List<BasePacket>>();
			foreach (CSteamID peer in Plugin.Instance.Network.Peers)
			{
				dictionary[peer] = new List<BasePacket>();
			}
			if (CaresAboutPeer)
			{
				foreach (var item in Targets())
				{
					if (!HandleDisabledTargets && !item.target.activeInHierarchy)
					{
						continue;
					}
					foreach (CSteamID peer2 in Plugin.Instance.Network.Peers)
					{
						if (!Filter(peer2, item.id, item.target))
						{
							if (!_states.TryGetValue((peer2, item.id), out var value))
							{
								value = new State();
								_states[(peer2, item.id)] = value;
							}
							BasePacket basePacket = PacketToSend(value, peer2, item.id, item.target);
							if (basePacket != null)
							{
								dictionary[peer2].Add(basePacket);
							}
						}
					}
				}
			}
			else
			{
				foreach (var item2 in Targets())
				{
					if (!HandleDisabledTargets && ((Object)(object)item2.target == (Object)null || !item2.target.activeInHierarchy))
					{
						continue;
					}
					if (!_states.TryGetValue((CSteamID.Nil, item2.id), out var value2))
					{
						value2 = new State();
						_states[(CSteamID.Nil, item2.id)] = value2;
					}
					BasePacket basePacket2 = PacketToSend(value2, CSteamID.Nil, item2.id, item2.target);
					if (basePacket2 == null)
					{
						continue;
					}
					foreach (CSteamID peer3 in Plugin.Instance.Network.Peers)
					{
						if (!Filter(peer3, item2.id, item2.target))
						{
							dictionary[peer3].Add(basePacket2);
						}
					}
				}
			}
			SteamNetworkingIdentity target = default(SteamNetworkingIdentity);
			foreach (KeyValuePair<CSteamID, List<BasePacket>> item3 in dictionary)
			{
				if (item3.Value.Count == 0)
				{
					continue;
				}
				((SteamNetworkingIdentity)(ref target)).SetSteamID(item3.Key);
				if (item3.Value.Count > 10)
				{
					Plugin.Instance.Network.SendSingle(new CombinedPacket
					{
						InnerPacketType = item3.Value[0].TypeID,
						Packets = item3.Value
					}, target);
					continue;
				}
				foreach (BasePacket item4 in item3.Value)
				{
					Plugin.Instance.Network.SendSingle(item4, target);
				}
			}
		}

		public void Reset()
		{
			_states.Clear();
		}

		public void OnConnected(CSteamID id)
		{
			//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)
			foreach (KeyValuePair<(CSteamID, IdentifierData), State> state in _states)
			{
				if (!CaresAboutPeer || !(state.Key.Item1 != id))
				{
					state.Value.ForceTimer = 0f;
					state.Value.MinWaitTimer = 0f;
					state.Value.LastPacket = null;
				}
			}
		}
	}
	public class EnemyPathfinderSync : BaseTargetSync
	{
		protected override float MinWaitTimer => 0.1f;

		protected override IEnumerable<(IdentifierData id, GameObject target)> Targets()
		{
			foreach (var data in Identifier.GetIdentifiers(IdentifierType.Enemy))
			{
				if (!((Object)(object)data.target == (Object)null) && !((Object)(object)data.target.GetComponent<PathfindMovementEnemy>() == (Object)null))
				{
					IdentifierData item = new IdentifierData
					{
						Type = IdentifierType.Enemy
					};
					(item.Id, _) = data;
					yield return (id: item, target: data.target);
				}
			}
		}

		protected override BasePacket CreateSyncPacket(CSteamID peer, IdentifierData id, GameObject target)
		{
			PathfindMovementEnemy component = target.GetComponent<PathfindMovementEnemy>();
			Traverse<TaggedObject> val = Traverse.Create((object)component).Field<TaggedObject>("seekToTaggedObj");
			Traverse<int> val2 = Traverse.Create((object)component).Field<int>("nextPathPointIndex");
			Traverse<List<Vector3>> val3 = Traverse.Create((object)component).Field<List<Vector3>>("path");
			IdentifierData targetObject = IdentifierData.Invalid;
			if ((Object)(object)val.Value != (Object)null)
			{
				targetObject = new IdentifierData(((Component)val.Value).GetComponent<Identifier>());
			}
			return new SyncEnemyPathfinderPacket
			{
				Enemy = id.Id,
				TargetObject = targetObject,
				Slowed = ((PathfindMovement)component).IsSlowed,
				PathIndex = (ushort)val2.Value,
				Path = val3.Value
			};
		}

		protected override bool Compare(CSteamID peer, IdentifierData id, GameObject target, BasePacket current, BasePacket last)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			SyncEnemyPathfinderPacket syncEnemyPathfinderPacket = (SyncEnemyPathfinderPacket)current;
			SyncEnemyPathfinderPacket syncEnemyPathfinderPacket2 = (SyncEnemyPathfinderPacket)last;
			if (syncEnemyPathfinderPacket.Path.Count != syncEnemyPathfinderPacket2.Path.Count)
			{
				return false;
			}
			for (int i = 0; i < syncEnemyPathfinderPacket.Path.Count; i++)
			{
				Vector3 val = syncEnemyPathfinderPacket.Path[i] - syncEnemyPathfinderPacket2.Path[i];
				if (((Vector3)(ref val)).sqrMagnitude > 0.0025f)
				{
					return false;
				}
			}
			return syncEnemyPathfinderPacket.TargetObject.Type == syncEnemyPathfinderPacket2.TargetObject.Type && syncEnemyPathfinderPacket.TargetObject.Id == syncEnemyPathfinderPacket2.TargetObject.Id && syncEnemyPathfinderPacket.Slowed == syncEnemyPathfinderPacket2.Slowed;
		}

		public override bool CanHandle(BasePacket packet)
		{
			return packet.TypeID == PacketId.SyncEnemyPathfinder;
		}

		public override void Handle(CSteamID peer, BasePacket packet)
		{
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			SyncEnemyPathfinderPacket syncEnemyPathfinderPacket = (SyncEnemyPathfinderPacket)packet;
			GameObject gameObject = Identifier.GetGameObject(IdentifierType.Enemy, syncEnemyPathfinderPacket.Enemy);
			if ((Object)(object)gameObject == (Object)null)
			{
				Plugin.Log.LogInfoFiltered("PathfindingEnemySync", $"Enemy {syncEnemyPathfinderPacket.Enemy} not found, discarding");
				return;
			}
			PathfindMovementEnemy component = gameObject.GetComponent<PathfindMovementEnemy>();
			Traverse<Vector3> val = Traverse.Create((object)component).Field<Vector3>("seekToTargetPos");
			Traverse<bool> val2 = Traverse.Create((object)component).Field<bool>("currentlyWalkingHome");
			Traverse<bool> val3 = Traverse.Create((object)component).Field<bool>("currentlyChasingPlayer");
			Traverse<float> val4 = Traverse.Create((object)component).Field<float>("slowedFor");
			Traverse<int> val5 = Traverse.Create((object)component).Field<int>("nextPathPointIndex");
			Traverse<Vector3> val6 = Traverse.Create((object)component).Field<Vector3>("homeOffset");
			Traverse<List<Vector3>> val7 = Traverse.Create((object)component).Field<List<Vector3>>("path");
			Traverse<TaggedObject> val8 = Traverse.Create((object)component).Field<TaggedObject>("seekToTaggedObj");
			GameObject val9 = syncEnemyPathfinderPacket.TargetObject.Get();
			bool flag = syncEnemyPathfinderPacket.TargetObject.Type == IdentifierType.Invalid;
			val.Value = (flag ? (component.HomePosition + val6.Value) : val9.transform.position);
			val8.Value = (flag ? null : val9.GetComponent<TaggedObject>());
			val2.Value = flag;
			val3.Value = syncEnemyPathfinderPacket.TargetObject.Type == IdentifierType.Player;
			val4.Value = (syncEnemyPathfinderPacket.Slowed ? float.MaxValue : float.MinValue);
			val5.Value = syncEnemyPathfinderPacket.PathIndex;
			val7.Value = syncEnemyPathfinderPacket.Path;
		}
	}
	public class HpSync : BaseTargetSync
	{
		protected override bool HandleDisabledTargets => true;

		protected override float ForceUpdateTimer => 3f;

		protected override IEnumerable<(IdentifierData id, GameObject target)> Targets()
		{
			foreach (var data in Identifier.GetIdentifiers(IdentifierType.Player))
			{
				IdentifierData item = new IdentifierData
				{
					Type = IdentifierType.Player
				};
				(item.Id, _) = data;
				yield return (id: item, target: data.target);
			}
			foreach (var data2 in Identifier.GetIdentifiers(IdentifierType.Building))
			{
				IdentifierData item = new IdentifierData
				{
					Type = IdentifierType.Building
				};
				(item.Id, _) = data2;
				yield return (id: item, target: data2.target);
			}
			foreach (var data3 in Identifier.GetIdentifiers(IdentifierType.Ally))
			{
				IdentifierData item = new IdentifierData
				{
					Type = IdentifierType.Ally
				};
				(item.Id, _) = data3;
				yield return (id: item, target: data3.target);
			}
			foreach (var data4 in Identifier.GetIdentifiers(IdentifierType.Enemy))
			{
				IdentifierData item = new IdentifierData
				{
					Type = IdentifierType.Enemy
				};
				(item.Id, _) = data4;
				yield return (id: item, target: data4.target);
			}
			foreach (var data5 in Identifier.GetIdentifiers(IdentifierType.Enemy))
			{
				IdentifierData item = new IdentifierData
				{
					Type = IdentifierType.Enemy
				};
				(item.Id, _) = data5;
				yield return (id: item, target: data5.target);
			}
			foreach (ushort data6 in Identifier.GetDestroyed(IdentifierType.Enemy))
			{
				yield return (id: new IdentifierData
				{
					Type = IdentifierType.Enemy,
					Id = data6
				}, target: null);
			}
		}

		protected override BasePacket CreateSyncPacket(CSteamID peer, IdentifierData id, GameObject target)
		{
			if ((Object)(object)target != (Object)null)
			{
				Hp component = target.GetComponent<Hp>();
				if ((Object)(object)component != (Object)null)
				{
					return new SyncHpPacket
					{
						Target = id,
						Hp = component.HpValue,
						MaxHp = component.maxHp,
						KnockedOut = component.KnockedOut,
						Invulnerable = component.invulnerable
					};
				}
			}
			return new SyncHpPacket
			{
				Target = id,
				Hp = -2.1474836E+09f,
				MaxHp = 10f,
				KnockedOut = true,
				Invulnerable = false
			};
		}

		protected override bool Compare(CSteamID peer, IdentifierData id, GameObject target, BasePacket current, BasePacket last)
		{
			SyncHpPacket syncHpPacket = (SyncHpPacket)current;
			SyncHpPacket syncHpPacket2 = (SyncHpPacket)last;
			return Math.Abs(syncHpPacket.Hp - syncHpPacket2.Hp) < 1.8E-43f && Math.Abs(syncHpPacket.MaxHp - syncHpPacket2.MaxHp) < 1.8E-43f && syncHpPacket.KnockedOut == syncHpPacket2.KnockedOut && syncHpPacket.Invulnerable == syncHpPacket2.Invulnerable;
		}

		public override bool CanHandle(BasePacket packet)
		{
			return packet.TypeID == PacketId.SyncHp;
		}

		public override void Handle(CSteamID peer, BasePacket packet)
		{
			SyncHpPacket syncHpPacket = (SyncHpPacket)packet;
			GameObject val = syncHpPacket.Target.Get();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Hp component = val.GetComponent<Hp>();
			if ((Object)(object)component == (Object)null || (Object)(object)component.TaggedObj == (Object)null)
			{
				return;
			}
			component.maxHp = syncHpPacket.MaxHp;
			float num = syncHpPacket.Hp - component.HpValue;
			HpPatch.AllowHealthChangeOnClient = true;
			component.invulnerable = false;
			if (num > 0f)
			{
				if (((Component)component).gameObject.activeInHierarchy)
				{
					if (component.KnockedOut && !syncHpPacket.KnockedOut)
					{
						component.Revive(true, syncHpPacket.Hp / component.maxHp);
						if (syncHpPacket.Target.Type == IdentifierType.Ally)
						{
							PathfindMovementPlayerunit component2 = ((Component)component).GetComponent<PathfindMovementPlayerunit>();
							component2.SnapToNavmesh();
						}
					}
					else if (!syncHpPacket.KnockedOut)
					{
						component.Heal(num);
					}
				}
			}
			else
			{
				component.TakeDamage(0f - num, (TaggedObject)null, false, false);
			}
			component.invulnerable = syncHpPacket.Invulnerable;
			HpPatch.AllowHealthChangeOnClient = false;
		}
	}
	public class InputSync : BaseTargetSync
	{
		protected override bool ShouldUpdate => true;

		protected override bool HandleDisabledTargets => true;

		protected override IEnumerable<(IdentifierData id, GameObject target)> Targets()
		{
			if (Plugin.Instance.Network.Server)
			{
				foreach (PlayerManager.Player player in Plugin.Instance.PlayerManager.GetAllPlayers())
				{
					yield return (id: new IdentifierData
					{
						Type = IdentifierType.Player,
						Id = player.Id
					}, target: player.Object);
				}
			}
			else if (Plugin.Instance.PlayerManager.LocalPlayer != null)
			{
				yield return (id: new IdentifierData
				{
					Type = IdentifierType.Player,
					Id = Plugin.Instance.PlayerManager.LocalId
				}, target: Plugin.Instance.PlayerManager.LocalPlayer.Object);
			}
		}

		protected override BasePacket CreateSyncPacket(CSteamID peer, IdentifierData id, GameObject target)
		{
			SyncPlayerInputPacket syncPlayerInputPacket = new SyncPlayerInputPacket
			{
				PlayerID = id.Id
			};
			syncPlayerInputPacket.Data.Set(Plugin.Instance.PlayerManager.Get((int)id.Id).Shared);
			return syncPlayerInputPacket;
		}

		protected override bool Compare(CSteamID peer, IdentifierData id, GameObject target, BasePacket current, BasePacket last)
		{
			SyncPlayerInputPacket syncPlayerInputPacket = (SyncPlayerInputPacket)current;
			SyncPlayerInputPacket syncPlayerInputPacket2 = (SyncPlayerInputPacket)last;
			return syncPlayerInputPacket.Data.Compare(syncPlayerInputPacket2.Data);
		}

		protected override bool Filter(CSteamID peer, IdentifierData id, GameObject target)
		{
			//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)
			return Plugin.Instance.PlayerManager.Get((int)id.Id).SteamID == peer;
		}

		public override bool CanHandle(BasePacket packet)
		{
			return packet.TypeID == PacketId.SyncPlayerInput;
		}

		public override void Handle(CSteamID peer, BasePacket packet)
		{
			SyncPlayerInputPacket syncPlayerInputPacket = (SyncPlayerInputPacket)packet;
			PlayerManager.Player player = Plugin.Instance.PlayerManager.Get((int)syncPlayerInputPacket.PlayerID);
			if (player != null && player.Id != Plugin.Instance.PlayerManager.LocalId)
			{
				player.Shared.Set(syncPlayerInputPacket.Data);
			}
		}
	}
	public class LevelDataSync : BaseSync
	{
		private class LevelRequest
		{
			public string To;

			public string From;

			public readonly Dictionary<int, Equipment> SelectedWeapons = new Dictionary<int, Equipment>();
		}

		private const float ResendWeaponRequestTime = 4f;

		private LevelRequest _activeRequest;

		private WeaponDialog _activeDialog;

		protected override bool ShouldUpdate => Plugin.Instance.Network.Server && SceneTransitionManagerPatch.CurrentScene != "_StartMenu";

		protected override BasePacket CreateSyncPacket(CSteamID peer)
		{
			SyncLevelDataPacket syncLevelDataPacket = new SyncLevelDataPacket
			{
				Level = SceneTransitionManagerPatch.CurrentScene
			};
			foreach (PlayerManager.Player allPlayer in Plugin.Instance.PlayerManager.GetAllPlayers())
			{
				syncLevelDataPacket.PlayerData.Add(new SyncLevelDataPacket.Player
				{
					PlayerId = allPlayer.Id,
					SpawnId = allPlayer.SpawnID,
					Weapon = allPlayer.Weapon
				});
			}
			foreach (Equippable item in PerkManager.instance.CurrentlyEquipped)
			{
				Equipment equipment = Equip.Convert(((Object)item).name);
				if ((uint)(equipment - 2) > 2u)
				{
					syncLevelDataPacket.Perks.Add(equipment);
				}
			}
			return syncLevelDataPacket;
		}

		protected override bool Compare(CSteamID peer, BasePacket current, BasePacket last)
		{
			SyncLevelDataPacket syncLevelDataPacket = (SyncLevelDataPacket)current;
			SyncLevelDataPacket syncLevelDataPacket2 = (SyncLevelDataPacket)last;
			if (syncLevelDataPacket.Perks.Count != syncLevelDataPacket2.Perks.Count || syncLevelDataPacket.PlayerData.Count != syncLevelDataPacket2.PlayerData.Count)
			{
				return false;
			}
			for (int i = 0; i < syncLevelDataPacket.Perks.Count; i++)
			{
				if (syncLevelDataPacket.Perks[i] != syncLevelDataPacket2.Perks[i])
				{
					return false;
				}
			}
			for (int j = 0; j < syncLevelDataPacket.PlayerData.Count; j++)
			{
				SyncLevelDataPacket.Player player = syncLevelDataPacket.PlayerData[j];
				SyncLevelDataPacket.Player player2 = syncLevelDataPacket2.PlayerData[j];
				ushort playerId = player.PlayerId;
				byte spawnId = player.SpawnId;
				Equipment weapon = player.Weapon;
				ushort playerId2 = player2.PlayerId;
				byte spawnId2 = player2.SpawnId;
				Equipment weapon2 = player2.Weapon;
				if (playerId != playerId2 || spawnId != spawnId2 || weapon != weapon2)
				{
					return false;
				}
			}
			return syncLevelDataPacket.Level == syncLevelDataPacket2.Level;
		}

		public override bool CanHandle(BasePacket packet)
		{
			PacketId typeID = packet.TypeID;
			if (typeID == PacketId.SyncLevelData || (uint)(typeID - 18) <= 1u || (uint)(typeID - 22) <= 1u)
			{
				return true;
			}
			return false;
		}

		private void HandleRequestPacket(CSteamID peer, RequestLevelPacket packet)
		{
			//IL_002b: 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_0045: 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_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			if (_activeRequest != null)
			{
				return;
			}
			if (packet.From != SceneTransitionManagerPatch.CurrentScene)
			{
				SteamNetworkingIdentity target = default(SteamNetworkingIdentity);
				((SteamNetworkingIdentity)(ref target)).SetSteamID(peer);
				Plugin.Instance.Network.SendSingle(CreateSyncPacket(peer), target);
				return;
			}
			if (packet.To == "_LevelSelect")
			{
				SceneTransitionManagerPatch.Transition(packet.To, packet.From);
				return;
			}
			if (packet.To == packet.From)
			{
				Equip.ClearEquipments();
				foreach (Equipment perk in packet.Perks)
				{
					if (perk != Equipment.Invalid && !Equip.Weapons.Contains(perk))
					{
						Equip.EquipEquipment(perk);
					}
				}
				Equip.EquipEquipment(Plugin.Instance.PlayerManager.LocalPlayer.Weapon);
				Plugin.Instance.Network.Send(new RestartLevelPacket
				{
					OverwriteSave = packet.OverwriteSave
				}, handleLocal: true);
				return;
			}
			_activeRequest = new LevelRequest
			{
				To = packet.To,
				From = packet.From
			};
			Equip.ClearEquipments();
			foreach (Equipment perk2 in packet.Perks)
			{
				if (Equip.Weapons.Contains(perk2))
				{
					_activeRequest.SelectedWeapons[Plugin.Instance.PlayerManager.Get(peer).Id] = perk2;
				}
				else
				{
					Equip.EquipEquipment(perk2);
				}
			}
			foreach (KeyValuePair<ushort, Equipment> weaponPick in LoadoutState.WeaponPicks)
			{
				if (weaponPick.Value != Equipment.Invalid && !_activeRequest.SelectedWeapons.ContainsKey(weaponPick.Key))
				{
					_activeRequest.SelectedWeapons[weaponPick.Key] = weaponPick.Value;
				}
			}
			if (!Plugin.Instance.PlayerManager.GetAllPlayers().All((PlayerManager.Player p) => _activeRequest.SelectedWeapons.ContainsKey(p.Id)))
			{
				Plugin.Log.LogInfo((object)"Sending weapon request.");
				bool flag = peer == Plugin.Instance.PlayerManager.LocalPlayer.SteamID;
				WeaponRequestPacket basePacket = new WeaponRequestPacket();
				Plugin.Instance.Network.Send(basePacket, !flag, peer);
			}
			((MonoBehaviour)Plugin.Instance).StartCoroutine(RequestHandler());
		}

		private void ResendWeaponRequest()
		{
			//IL_0003: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			SteamNetworkingIdentity target = default(SteamNetworkingIdentity);
			WeaponRequestPacket basePacket = new WeaponRequestPacket();
			foreach (PlayerManager.Player allPlayer in Plugin.Instance.PlayerManager.GetAllPlayers())
			{
				if (!_activeRequest.SelectedWeapons.ContainsKey(allPlayer.Id))
				{
					((SteamNetworkingIdentity)(ref target)).SetSteamID(allPlayer.SteamID);
					Plugin.Instance.Network.SendSingle(basePacket, target);
				}
			}
		}

		private IEnumerator RequestHandler()
		{
			float timer = 0f;
			while (_activeRequest != null && !Plugin.Instance.PlayerManager.GetAllPlayers().All((PlayerManager.Player p) => _activeRequest.SelectedWeapons.ContainsKey(p.Id)))
			{
				timer += Time.deltaTime;
				if (timer > 4f)
				{
					ResendWeaponRequest();
					timer = 0f;
				}
				yield return null;
			}
			if (_activeRequest == null)
			{
				yield break;
			}
			foreach (KeyValuePair<int, Equipment> weapon in _activeRequest.SelectedWeapons)
			{
				PlayerManager.Player player = Plugin.Instance.PlayerManager.Get(weapon.Key);
				if (player != null)
				{
					player.Weapon = weapon.Value;
					if (player.Id == Plugin.Instance.PlayerManager.LocalId)
					{
						Equip.EquipEquipment(player.Weapon);
					}
				}
			}
			SceneTransitionManagerPatch.Transition(_activeRequest.To, _activeRequest.From);
			_activeRequest = null;
		}

		private static void HandleSyncPacket(SyncLevelDataPacket packet)
		{
			Equip.ClearEquipments();
			foreach (Equipment perk in packet.Perks)
			{
				Equip.EquipEquipment(perk);
			}
			foreach (SyncLevelDataPacket.Player playerDatum in packet.PlayerData)
			{
				PlayerManager.Player player = Plugin.Instance.PlayerManager.Get((int)playerDatum.PlayerId);
				player.SpawnID = playerDatum.SpawnId;
				player.Weapon = playerDatum.Weapon;
				if (player.Id == Plugin.Instance.PlayerManager.LocalId)
				{
					Equip.EquipEquipment(player.Weapon);
				}
			}
			if (packet.Level != SceneTransitionManagerPatch.CurrentScene)
			{
				SceneTransitionManagerPatch.Transition(packet.Level, SceneTransitionManagerPatch.CurrentScene);
			}
		}

		private void HandleWeaponRequestPacket()
		{
			if (!((Object)(object)_activeDialog != (Object)null))
			{
				_activeDialog = UIManager.CreateWeaponDialog();
			}
		}

		private void HandleWeaponResponsePacket(CSteamID peer, WeaponResponsePacket packet)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (_activeRequest != null)
			{
				_activeRequest.SelectedWeapons[Plugin.Instance.PlayerManager.Get(peer).Id] = packet.Weapon;
			}
		}

		protected override void HandlePacket(CSteamID peer, BasePacket packet)
		{
			//IL_0042: 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)
			switch (packet.TypeID)
			{
			case PacketId.SyncLevelData:
				HandleSyncPacket((SyncLevelDataPacket)packet);
				break;
			case PacketId.RequestLevel:
				HandleRequestPacket(peer, (RequestLevelPacket)packet);
				break;
			case PacketId.RestartLevel:
				MatchSaveLoadHandler.OverwriteCurrentSave = ((RestartLevelPacket)packet).OverwriteSave;
				SceneTransitionManagerPatch.Transition(SceneTransitionManagerPatch.CurrentScene, SceneTransitionManagerPatch.CurrentScene);
				break;
			case PacketId.WeaponRequest:
				HandleWeaponRequestPacket();
				break;
			case PacketId.WeaponResponse:
				HandleWeaponResponsePacket(peer, (WeaponResponsePacket)packet);
				break;
			}
		}
	}
	public class PingPongSync : BaseSync
	{
		protected override float ForceUpdateTimer => 2f;

		protected override BasePacket CreateSyncPacket(CSteamID peer)
		{
			return SyncPingPacket.WithTime();
		}

		protected override bool Compare(CSteamID peer, BasePacket current, BasePacket last)
		{
			return true;
		}

		public override bool CanHandle(BasePacket packet)
		{
			PacketId typeID = packet.TypeID;
			if ((uint)(typeID - 3) <= 2u)
			{
				return true;
			}
			return false;
		}

		protected override void HandlePacket(CSteamID peer, BasePacket packet)
		{
			//IL_0019: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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)
			switch (packet.TypeID)
			{
			case PacketId.SyncPing:
			{
				SteamNetworkingIdentity target = default(SteamNetworkingIdentity);
				((SteamNetworkingIdentity)(ref target)).SetSteamID(peer);
				Plugin.Instance.Network.SendSingle(SyncPongPacket.FromPing((SyncPingPacket)packet), target);
				break;
			}
			case PacketId.SyncPong:
			{
				SyncPongPacket pong = (SyncPongPacket)packet;
				Plugin.Instance.Network.Send(SyncPingInfoPacket.FromPong(peer, pong), handleLocal: true);
				break;
			}
			default:
			{
				SyncPingInfoPacket syncPingInfoPacket = (SyncPingInfoPacket)packet;
				Plugin.Instance.PlayerManager.Get(syncPingInfoPacket.Peer).Ping = syncPingInfoPacket.Ping;
				break;
			}
			}
		}
	}
	public class PositionSync : BaseTargetSync
	{
		private class DevianceConstant
		{
			public readonly float MinWeight;

			public readonly float MaxWeight;

			public readonly float MinDistance;

			public readonly float MaxDistance;

			public DevianceConstant(float minWeight, float maxWeight, float minDistance, float maxDistance)
			{
				MinWeight = minWeight;
				MaxWeight = maxWeight;
				MinDistance = minDistance;
				MaxDistance = maxDistance;
			}
		}

		private readonly Dictionary<IdentifierType, DevianceConstant> _devianceConstants = new Dictionary<IdentifierType, DevianceConstant>
		{
			{
				IdentifierType.Player,
				new DevianceConstant(0.35f, 1f, 1f, 10f)
			},
			{
				IdentifierType.Ally,
				new DevianceConstant(0.5f, 1f, 0.5f, 8f)
			},
			{
				IdentifierType.Enemy,
				new DevianceConstant(0.5f, 1f, 0.5f, 8f)
			}
		};

		private const float EnemyAllySnapDistance = 7f;

		protected override bool ShouldUpdate => true;

		protected override float MinWaitTimer => 0.05f;

		protected override float ForceUpdateTimer => 1f;

		private Vector3 CalculatePosition(IdentifierType type, float speed, Vector3 a, Vector3 b)
		{
			//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_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0066: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = a - b;
			float magnitude = ((Vector3)(ref val)).magnitude;
			DevianceConstant devianceConstant = _devianceConstants[type];
			float maxDistance = devianceConstant.MaxDistance;
			float num = (magnitude - devianceConstant.MinDistance) / (maxDistance - devianceConstant.MinDistance);
			num = Mathf.Clamp(num, 0f, 1f);
			return Vector3.Lerp(a, b, Mathf.Lerp(devianceConstant.MinWeight, devianceConstant.MaxWeight, num));
		}

		protected override IEnumerable<(IdentifierData id, GameObject target)> Targets()
		{
			if (Plugin.Instance.Network.Server)
			{
				foreach (KeyValuePair<IdentifierType, DevianceConstant> entry in _devianceConstants)
				{
					foreach (var data in Identifier.GetIdentifiers(entry.Key))
					{
						IdentifierData item = new IdentifierData
						{
							Type = entry.Key
						};
						(item.Id, _) = data;
						yield return (id: item, target: data.target);
					}
				}
			}
			else if ((Object)(object)Plugin.Instance.PlayerManager.LocalPlayer?.Object != (Object)null)
			{
				yield return (id: new IdentifierData
				{
					Type = IdentifierType.Player,
					Id = Plugin.Instance.PlayerManager.LocalId
				}, target: Plugin.Instance.PlayerManager.LocalPlayer.Object);
			}
		}

		protected override BasePacket CreateSyncPacket(CSteamID peer, IdentifierData id, GameObject target)
		{
			//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)
			return new SyncPositionPacket
			{
				Target = id,
				Position = target.transform.position
			};
		}

		protected override bool Compare(CSteamID peer, IdentifierData id, GameObject target, BasePacket current, BasePacket last)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			SyncPositionPacket syncPositionPacket = (SyncPositionPacket)current;
			SyncPositionPacket syncPositionPacket2 = (SyncPositionPacket)last;
			Vector3 val = syncPositionPacket.Position - syncPositionPacket2.Position;
			return ((Vector3)(ref val)).sqrMagnitude < 0.0025f;
		}

		protected override bool Filter(CSteamID peer, IdentifierData id, GameObject target)
		{
			//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)
			return id.Type == IdentifierType.Player && Plugin.Instance.PlayerManager.Get((int)id.Id).SteamID == peer;
		}

		public override bool CanHandle(BasePacket packet)
		{
			return packet.TypeID == PacketId.SyncPosition;
		}

		public override void Handle(CSteamID peer, BasePacket packet)
		{
			//IL_013b: 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_00f1: 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)
			SyncPositionPacket syncPositionPacket = (SyncPositionPacket)packet;
			GameObject val = syncPositionPacket.Target.Get();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if (syncPositionPacket.Target.Type == IdentifierType.Player)
			{
				PlayerNetworkData component = val.GetComponent<PlayerNetworkData>();
				PlayerMovement component2 = val.GetComponent<PlayerMovement>();
				float num = (component2.Sprinting ? component2.sprintSpeed : component2.speed);
				Traverse<bool> val2 = Traverse.Create((object)component2).Field<bool>("heavyArmorEquipped");
				Traverse<bool> val3 = Traverse.Create((object)component2).Field<bool>("racingHorseEquipped");
				if (val2.Value)
				{
					num *= PerkManager.instance.heavyArmor_SpeedMultiplyer;
				}
				if (val3.Value)
				{
					num *= PerkManager.instance.racingHorse_SpeedMultiplyer;
				}
				((Collider)component.Player.Controller).enabled = false;
				val.transform.position = CalculatePosition(IdentifierType.Player, num, val.transform.position, syncPositionPacket.Position);
				((Collider)component.Player.Controller).enabled = true;
			}
			else
			{
				PositionErrorSmoother positionErrorSmoother = val.GetComponent<PositionErrorSmoother>();
				if ((Object)(object)positionErrorSmoother == (Object)null)
				{
					positionErrorSmoother = val.AddComponent<PositionErrorSmoother>();
				}
				positionErrorSmoother.ApplyCorrection(syncPositionPacket.Position, 7f);
			}
		}
	}
	public class ResourceSync : BaseSync
	{
		protected override BasePacket CreateSyncPacket(CSteamID peer)
		{
			return new SyncResourcePacket
			{
				Balance = GlobalData.Internal.Balance,
				NetWorth = GlobalData.Internal.NetWorth
			};
		}

		protected override bool Compare(CSteamID peer, BasePacket current, BasePacket last)
		{
			SyncResourcePacket syncResourcePacket = (SyncResourcePacket)current;
			SyncResourcePacket syncResourcePacket2 = (SyncResourcePacket)last;
			return syncResourcePacket.Balance == syncResourcePacket2.Balance && syncResourcePacket.NetWorth == syncResourcePacket2.NetWorth;
		}

		public override bool CanHandle(BasePacket packet)
		{
			return packet.TypeID == PacketId.SyncResource;
		}

		protected override void HandlePacket(CSteamID peer, BasePacket packet)
		{
			SyncResourcePacket syncResourcePacket = (SyncResourcePacket)packet;
			GlobalData.Internal.Balance = syncResourcePacket.Balance;
			GlobalData.Internal.NetWorth = syncResourcePacket.NetWorth;
		}
	}
	public static class SyncManager
	{
		private static readonly List<BaseSync> RegisteredSyncs = new List<BaseSync>();

		private static readonly List<BaseTargetSync> RegisteredTargetSyncs = new List<BaseTargetSync>();

		public static void RegisterSync(BaseSync sync)
		{
			RegisteredSyncs.Add(sync);
		}

		public static void RegisterSync(BaseTargetSync sync)
		{
			RegisteredTargetSyncs.Add(sync);
		}

		public static void UpdateSyncs()
		{
			foreach (BaseSync registeredSync in RegisteredSyncs)
			{
				registeredSync.Update();
			}
			foreach (BaseTargetSync registeredTargetSync in RegisteredTargetSyncs)
			{
				registeredTargetSync.Update();
			}
		}

		public static void ResetSyncs()
		{
			foreach (BaseSync registeredSync in RegisteredSyncs)
			{
				registeredSync.Reset();
			}
			foreach (BaseTargetSync registeredTargetSync in RegisteredTargetSyncs)
			{
				registeredTargetSync.Reset();
			}
		}

		public static void OnConnected(CSteamID id)
		{
			//IL_0019: 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)
			foreach (BaseSync registeredSync in RegisteredSyncs)
			{
				registeredSync.OnConnected(id);
			}
			foreach (BaseTargetSync registeredTargetSync in RegisteredTargetSyncs)
			{
				registeredTargetSync.OnConnected(id);
			}
		}

		public static bool HandlePacket(SteamNetworkingIdentity sender, BasePacket packet)
		{
			//IL_002c: 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)
			foreach (BaseSync registeredSync in RegisteredSyncs)
			{
				if (!registeredSync.CanHandle(packet))
				{
					continue;
				}
				registeredSync.Handle(((SteamNetworkingIdentity)(ref sender)).GetSteamID(), packet);
				return true;
			}
			foreach (BaseTargetSync registeredTargetSync in RegisteredTargetSyncs)
			{
				if (!registeredTargetSync.CanHandle(packet))
				{
					continue;
				}
				registeredTargetSync.Handle(((SteamNetworkingIdentity)(ref sender)).GetSteamID(), packet);
				return true;
			}
			return false;
		}
	}
}
namespace ThronefallMP.Network.Packets
{
	public abstract class BaseOrderedPacket : BasePacket
	{
		private static int _next;

		private int _sentByPlayer = Plugin.Instance.PlayerManager.LocalId;

		private int _count = _next++;

		public override int DeliveryMask => 1;

		public (int player, int count) GetOrder()
		{
			return (player: _sentByPlayer, count: _count);
		}

		public override void Send(Buffer writer)
		{
			writer.Write(_count);
			writer.Write(_sentByPlayer);
		}

		public override void Receive(Buffer reader)
		{
			_count = reader.ReadInt32();
			_sentByPlayer = reader.ReadInt32();
		}
	}
	public abstract class BasePacket
	{
		public abstract PacketId TypeID { get; }

		public virtual int DeliveryMask => 9;

		public abstract Channel Channel { get; }

		public virtual bool ShouldPropagate => false;

		public virtual bool CanHandle(CSteamID sender)
		{
			return true;
		}

		public abstract void Send(Buffer writer);

		public abstract void Receive(Buffer reader);
	}
}
namespace ThronefallMP.Network.Packets.Sync
{
	public class SyncAllyPathfinderPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.SyncAllyPathfinder;

		public ushort Ally;

		public IdentifierData TargetObject;

		public Vector3 HomePosition;

		public bool HasReachedHomePositionAlready;

		public bool Slowed;

		public ushort PathIndex;

		public List<Vector3> Path = new List<Vector3>();

		public override PacketId TypeID => PacketId.SyncAllyPathfinder;

		public override Channel Channel => Channel.SyncUnit;

		public override int DeliveryMask => 8;

		public override void Send(Buffer writer)
		{
			//IL_001d: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(Ally);
			writer.Write(TargetObject);
			writer.Write(HomePosition);
			writer.Write(Slowed);
			writer.Write(PathIndex);
			writer.Write((ushort)Path.Count);
			foreach (Vector3 item in Path)
			{
				writer.Write(item);
			}
		}

		public override void Receive(Buffer reader)
		{
			//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_005c: Unknown result type (might be due to invalid IL or missing references)
			Path.Clear();
			Ally = reader.ReadUInt16();
			TargetObject = reader.ReadIdentifierData();
			HomePosition = reader.ReadVector3();
			Slowed = reader.ReadBoolean();
			PathIndex = reader.ReadUInt16();
			ushort num = reader.ReadUInt16();
			for (int i = 0; i < num; i++)
			{
				Path.Add(reader.ReadVector3());
			}
		}
	}
	public class SyncEnemyPathfinderPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.SyncEnemyPathfinder;

		public ushort Enemy;

		public IdentifierData TargetObject;

		public bool Slowed;

		public ushort PathIndex;

		public List<Vector3> Path = new List<Vector3>();

		public override PacketId TypeID => PacketId.SyncEnemyPathfinder;

		public override Channel Channel => Channel.SyncUnit;

		public override int DeliveryMask => 8;

		public override void Send(Buffer writer)
		{
			//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_0061: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(Enemy);
			writer.Write(TargetObject);
			writer.Write(Slowed);
			writer.Write(PathIndex);
			writer.Write((ushort)Path.Count);
			foreach (Vector3 item in Path)
			{
				writer.Write(item);
			}
		}

		public override void Receive(Buffer reader)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			Path.Clear();
			Enemy = reader.ReadUInt16();
			TargetObject = reader.ReadIdentifierData();
			Slowed = reader.ReadBoolean();
			PathIndex = reader.ReadUInt16();
			ushort num = reader.ReadUInt16();
			for (int i = 0; i < num; i++)
			{
				Path.Add(reader.ReadVector3());
			}
		}
	}
	public class SyncHpPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.SyncHp;

		public IdentifierData Target;

		public float Hp;

		public float MaxHp;

		public bool KnockedOut;

		public bool Invulnerable;

		public override PacketId TypeID => PacketId.SyncHp;

		public override Channel Channel => Channel.Player;

		public override void Send(Buffer writer)
		{
			writer.Write(Target);
			writer.Write(Hp);
			writer.Write(KnockedOut);
			writer.Write(Invulnerable);
			writer.Write(MaxHp);
		}

		public override void Receive(Buffer reader)
		{
			Target = reader.ReadIdentifierData();
			Hp = reader.ReadFloat();
			KnockedOut = reader.ReadBoolean();
			Invulnerable = reader.ReadBoolean();
			MaxHp = reader.ReadFloat();
		}
	}
	public class SyncLevelDataPacket : BasePacket
	{
		public struct Player
		{
			public ushort PlayerId;

			public byte SpawnId;

			public Equipment Weapon;
		}

		public const PacketId PacketID = PacketId.SyncLevelData;

		public string Level;

		public List<Equipment> Perks = new List<Equipment>();

		public List<Player> PlayerData = new List<Player>();

		public override PacketId TypeID => PacketId.SyncLevelData;

		public override Channel Channel => Channel.Player;

		public override void Send(Buffer writer)
		{
			writer.Write(Level);
			writer.Write((byte)Perks.Count);
			foreach (Equipment perk in Perks)
			{
				writer.Write(perk);
			}
			writer.Write((byte)PlayerData.Count);
			foreach (Player playerDatum in PlayerData)
			{
				writer.Write(playerDatum.PlayerId);
				writer.Write(playerDatum.SpawnId);
				writer.Write(playerDatum.Weapon);
			}
		}

		public override void Receive(Buffer reader)
		{
			PlayerData.Clear();
			Level = reader.ReadString();
			byte b = reader.ReadByte();
			Perks.Clear();
			for (int i = 0; i < b; i++)
			{
				Perks.Add(reader.ReadEquipment());
			}
			byte b2 = reader.ReadByte();
			for (int j = 0; j < b2; j++)
			{
				PlayerData.Add(new Player
				{
					PlayerId = reader.ReadUInt16(),
					SpawnId = reader.ReadByte(),
					Weapon = reader.ReadEquipment()
				});
			}
		}
	}
	public class SyncPingPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.SyncPing;

		public uint TimeMs;

		public override PacketId TypeID => PacketId.SyncPing;

		public override Channel Channel => Channel.NetworkManagement;

		public static SyncPingPacket WithTime()
		{
			return new SyncPingPacket
			{
				TimeMs = (uint)(Time.unscaledTime * 1000f)
			};
		}

		public override void Send(Buffer writer)
		{
			writer.Write(TimeMs);
		}

		public override void Receive(Buffer reader)
		{
			TimeMs = reader.ReadUInt32();
		}
	}
	public class SyncPongPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.SyncPong;

		public uint TimeMs;

		public override PacketId TypeID => PacketId.SyncPong;

		public override Channel Channel => Channel.NetworkManagement;

		public static SyncPongPacket FromPing(SyncPingPacket ping)
		{
			return new SyncPongPacket
			{
				TimeMs = ping.TimeMs
			};
		}

		public override void Send(Buffer writer)
		{
			writer.Write(TimeMs);
		}

		public override void Receive(Buffer reader)
		{
			TimeMs = reader.ReadUInt32();
		}
	}
	public class SyncPingInfoPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.SyncPingInfo;

		public CSteamID Peer;

		public uint Ping;

		public override PacketId TypeID => PacketId.SyncPingInfo;

		public override Channel Channel => Channel.NetworkManagement;

		public override int DeliveryMask => 0;

		public static SyncPingInfoPacket FromPong(CSteamID sender, SyncPongPacket pong)
		{
			//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)
			return new SyncPingInfoPacket
			{
				Peer = sender,
				Ping = (uint)(Time.unscaledTime * 1000f) - pong.TimeMs
			};
		}

		public override void Send(Buffer writer)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(Peer);
			writer.Write(Ping);
		}

		public override void Receive(Buffer reader)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Peer = reader.ReadSteamID();
			Ping = reader.ReadUInt32();
		}
	}
	public class SyncPlayerInputPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.SyncPlayerInput;

		public ushort PlayerID;

		public PlayerNetworkData.Shared Data = new PlayerNetworkData.Shared();

		public override PacketId TypeID => PacketId.SyncPlayerInput;

		public override Channel Channel => Channel.Player;

		public override int DeliveryMask => 1;

		public override void Send(Buffer writer)
		{
			writer.Write(PlayerID);
			writer.Write(Data.MoveHorizontal);
			writer.Write(Data.MoveVertical);
			writer.Write(Data.SprintToggleButton);
			writer.Write(Data.SprintButton);
			writer.Write(Data.InteractButton);
			writer.Write(Data.CallNightButton);
			writer.Write(Data.CommandUnitsButton);
			writer.Write(Data.Slowed);
			writer.Write(Data.SelectAllArmy);
			writer.Write(Data.SelectAllMelee);
			writer.Write(Data.SelectAllRanged);
			writer.Write(Data.SelectAllHeroes);
		}

		public override void Receive(Buffer reader)
		{
			PlayerID = reader.ReadUInt16();
			Data.MoveHorizontal = reader.ReadFloat();
			Data.MoveVertical = reader.ReadFloat();
			Data.SprintToggleButton = reader.ReadBoolean();
			Data.SprintButton = reader.ReadBoolean();
			Data.InteractButton = reader.ReadBoolean();
			Data.CallNightButton = reader.ReadBoolean();
			Data.CommandUnitsButton = reader.ReadBoolean();
			Data.Slowed = reader.ReadBoolean();
			Data.SelectAllArmy = reader.ReadBoolean();
			Data.SelectAllMelee = reader.ReadBoolean();
			Data.SelectAllRanged = reader.ReadBoolean();
			Data.SelectAllHeroes = reader.ReadBoolean();
		}
	}
	public class SyncPlayersPacket : BasePacket
	{
		public struct Player
		{
			public ushort Id;

			public byte SpawnId;

			public Vector3 Position;

			public PlayerNetworkData.Shared Shared;
		}

		public const PacketId PacketID = PacketId.SyncPlayer;

		public List<Player> PlayerData = new List<Player>();

		public override PacketId TypeID => PacketId.SyncPlayer;

		public override Channel Channel => Channel.SyncPlayer;

		public override void Send(Buffer writer)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(PlayerData.Count);
			foreach (Player playerDatum in PlayerData)
			{
				writer.Write(playerDatum.Id);
				writer.Write(playerDatum.SpawnId);
				writer.Write(playerDatum.Position);
				writer.Write(playerDatum.Shared.MoveHorizontal);
				writer.Write(playerDatum.Shared.MoveVertical);
				writer.Write(playerDatum.Shared.SprintToggleButton);
				writer.Write(playerDatum.Shared.SprintButton);
				writer.Write(playerDatum.Shared.InteractButton);
				writer.Write(playerDatum.Shared.CallNightButton);
				writer.Write(playerDatum.Shared.CallNightFill);
				writer.Write(playerDatum.Shared.CommandUnitsButton);
				writer.Write(playerDatum.Shared.Slowed);
				writer.Write(playerDatum.Shared.SelectAllArmy);
				writer.Write(playerDatum.Shared.SelectAllMelee);
				writer.Write(playerDatum.Shared.SelectAllRanged);
				writer.Write(playerDatum.Shared.SelectAllHeroes);
			}
		}

		public override void Receive(Buffer reader)
		{
			//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)
			PlayerData.Clear();
			int num = reader.ReadInt32();
			for (int i = 0; i < num; i++)
			{
				PlayerData.Add(new Player
				{
					Id = reader.ReadUInt16(),
					SpawnId = reader.ReadByte(),
					Position = reader.ReadVector3(),
					Shared = new PlayerNetworkData.Shared
					{
						MoveHorizontal = reader.ReadFloat(),
						MoveVertical = reader.ReadFloat(),
						SprintToggleButton = reader.ReadBoolean(),
						SprintButton = reader.ReadBoolean(),
						InteractButton = reader.ReadBoolean(),
						CallNightButton = reader.ReadBoolean(),
						CallNightFill = reader.ReadFloat(),
						CommandUnitsButton = reader.ReadBoolean(),
						Slowed = reader.ReadBoolean(),
						SelectAllArmy = reader.ReadBoolean(),
						SelectAllMelee = reader.ReadBoolean(),
						SelectAllRanged = reader.ReadBoolean(),
						SelectAllHeroes = reader.ReadBoolean()
					}
				});
			}
		}
	}
	public class SyncPositionPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.SyncPosition;

		public IdentifierData Target;

		public Vector3 Position;

		public override PacketId TypeID => PacketId.SyncPosition;

		public override Channel Channel => Channel.SyncPositions;

		public override void Send(Buffer writer)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(Target);
			writer.Write(Position);
		}

		public override void Receive(Buffer reader)
		{
			//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)
			Target = reader.ReadIdentifierData();
			Position = reader.ReadVector3();
		}
	}
	public class SyncResourcePacket : BasePacket
	{
		public const PacketId PacketID = PacketId.SyncResource;

		public int Balance;

		public int NetWorth;

		public override PacketId TypeID => PacketId.SyncResource;

		public override Channel Channel => Channel.SyncPlayer;

		public override int DeliveryMask => 8;

		public override void Send(Buffer writer)
		{
			writer.Write(Balance);
			writer.Write(NetWorth);
		}

		public override void Receive(Buffer reader)
		{
			Balance = reader.ReadInt32();
			NetWorth = reader.ReadInt32();
		}
	}
}
namespace ThronefallMP.Network.Packets.PlayerCommand
{
	public class BuildOrUpgradePacket : BasePacket
	{
		public const PacketId PacketID = PacketId.BuildOrUpgrade;

		public ushort BuildingId;

		public byte Level;

		public byte Choice;

		public override PacketId TypeID => PacketId.BuildOrUpgrade;

		public override int DeliveryMask => 8;

		public override Channel Channel => Channel.Resources;

		public override bool CanHandle(CSteamID sender)
		{
			return Plugin.Instance.Network.Server;
		}

		public override void Send(Buffer writer)
		{
			writer.Write(BuildingId);
			writer.Write(Level);
			writer.Write(Choice);
		}

		public override void Receive(Buffer reader)
		{
			BuildingId = reader.ReadUInt16();
			Level = reader.ReadByte();
			Choice = reader.ReadByte();
		}
	}
	public class CancelBuildPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.CancelBuild;

		public ushort BuildingId;

		public override PacketId TypeID => PacketId.CancelBuild;

		public override int DeliveryMask => 8;

		public override Channel Channel => Channel.Resources;

		public override bool CanHandle(CSteamID sender)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return Plugin.Instance.Network.IsServer(sender);
		}

		public override void Send(Buffer writer)
		{
			writer.Write(BuildingId);
		}

		public override void Receive(Buffer reader)
		{
			BuildingId = reader.ReadUInt16();
		}
	}
	public class CommandAddPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.CommandAdd;

		public ushort Player;

		public List<IdentifierData> Units = new List<IdentifierData>();

		public override PacketId TypeID => PacketId.CommandAdd;

		public override Channel Channel => Channel.Player;

		public override bool CanHandle(CSteamID sender)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return Plugin.Instance.Network.IsServer(sender);
		}

		public override void Send(Buffer writer)
		{
			writer.Write(Player);
			writer.Write((byte)Units.Count);
			foreach (IdentifierData unit in Units)
			{
				writer.Write(unit);
			}
		}

		public override void Receive(Buffer reader)
		{
			Player = reader.ReadUInt16();
			byte b = reader.ReadByte();
			Units.Clear();
			for (int i = 0; i < b; i++)
			{
				Units.Add(reader.ReadIdentifierData());
			}
		}
	}
	public class CommandHoldPositionPacket : BasePacket
	{
		public struct UnitData
		{
			public IdentifierData Unit;

			public Vector3 Home;
		}

		public const PacketId PacketID = PacketId.CommandHoldPosition;

		public ushort Player;

		public List<UnitData> Units = new List<UnitData>();

		public override PacketId TypeID => PacketId.CommandHoldPosition;

		public override Channel Channel => Channel.Player;

		public override bool CanHandle(CSteamID sender)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return Plugin.Instance.Network.IsServer(sender);
		}

		public override void Send(Buffer writer)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(Player);
			writer.Write((byte)Units.Count);
			foreach (UnitData unit in Units)
			{
				writer.Write(unit.Unit);
				writer.Write(unit.Home);
			}
		}

		public override void Receive(Buffer reader)
		{
			//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)
			Player = reader.ReadUInt16();
			byte b = reader.ReadByte();
			Units.Clear();
			for (int i = 0; i < b; i++)
			{
				Units.Add(new UnitData
				{
					Unit = reader.ReadIdentifierData(),
					Home = reader.ReadVector3()
				});
			}
		}
	}
	public class CommandPlacePacket : BasePacket
	{
		public struct UnitData
		{
			public IdentifierData Unit;

			public Vector3 Home;
		}

		public const PacketId PacketID = PacketId.CommandPlace;

		public ushort Player;

		public List<UnitData> Units = new List<UnitData>();

		public override PacketId TypeID => PacketId.CommandPlace;

		public override Channel Channel => Channel.Player;

		public override bool CanHandle(CSteamID sender)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return Plugin.Instance.Network.IsServer(sender);
		}

		public override void Send(Buffer writer)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(Player);
			writer.Write((byte)Units.Count);
			foreach (UnitData unit in Units)
			{
				writer.Write(unit.Unit);
				writer.Write(unit.Home);
			}
		}

		public override void Receive(Buffer reader)
		{
			//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)
			Player = reader.ReadUInt16();
			byte b = reader.ReadByte();
			Units.Clear();
			for (int i = 0; i < b; i++)
			{
				Units.Add(new UnitData
				{
					Unit = reader.ReadIdentifierData(),
					Home = reader.ReadVector3()
				});
			}
		}
	}
	public class ConfirmBuildPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.ConfirmBuild;

		public ushort PlayerID;

		public ushort BuildingId;

		public byte Level;

		public byte Choice;

		public override PacketId TypeID => PacketId.ConfirmBuild;

		public override int DeliveryMask => 8;

		public override Channel Channel => Channel.Resources;

		public override bool CanHandle(CSteamID sender)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return Plugin.Instance.Network.IsServer(sender);
		}

		public override void Send(Buffer writer)
		{
			writer.Write(PlayerID);
			writer.Write(BuildingId);
			writer.Write(Level);
			writer.Write(Choice);
		}

		public override void Receive(Buffer reader)
		{
			PlayerID = reader.ReadUInt16();
			BuildingId = reader.ReadUInt16();
			Level = reader.ReadByte();
			Choice = reader.ReadByte();
		}
	}
	public class ManualAttackPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.ManualAttack;

		public ushort Player;

		public override PacketId TypeID => PacketId.ManualAttack;

		public override Channel Channel => Channel.Player;

		public override bool ShouldPropagate => true;

		public override void Send(Buffer writer)
		{
			writer.Write(Player);
		}

		public override void Receive(Buffer reader)
		{
			Player = reader.ReadUInt16();
		}
	}
}
namespace ThronefallMP.Network.Packets.Game
{
	public class BossSpawnPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.BossSpawn;

		public ushort SpawnRef;

		public ushort Id;

		public Vector3 Position;

		public int Coins;

		public bool Elite;

		public float DifficultyMulti;

		public override PacketId TypeID => PacketId.BossSpawn;

		public override Channel Channel => Channel.Game;

		public override bool CanHandle(CSteamID sender)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return Plugin.Instance.Network.IsServer(sender);
		}

		public override void Send(Buffer writer)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(SpawnRef);
			writer.Write(Id);
			writer.Write(Position);
			writer.Write(Coins);
			writer.Write(Elite);
			writer.Write(DifficultyMulti);
		}

		public override void Receive(Buffer reader)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			SpawnRef = reader.ReadUInt16();
			Id = reader.ReadUInt16();
			Position = reader.ReadVector3();
			Coins = reader.ReadInt32();
			Elite = reader.ReadBoolean();
			DifficultyMulti = reader.ReadFloat();
		}
	}
	public class CombinedPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.Combined;

		public PacketId InnerPacketType;

		public List<BasePacket> Packets = new List<BasePacket>();

		public override PacketId TypeID => PacketId.Combined;

		public override Channel Channel => Packets[0].Channel;

		public override int DeliveryMask => Packets[0].DeliveryMask;

		public override void Send(Buffer writer)
		{
			writer.Write(InnerPacketType);
			writer.Write((ushort)Packets.Count);
			foreach (BasePacket packet in Packets)
			{
				packet.Send(writer);
			}
		}

		public override void Receive(Buffer reader)
		{
			InnerPacketType = reader.ReadPacketId();
			ushort num = reader.ReadUInt16();
			for (int i = 0; i < num; i++)
			{
				BasePacket basePacket = Plugin.Instance.Network.CreatePacket(InnerPacketType);
				if (basePacket == null)
				{
					Plugin.Log.LogWarning((object)$"Unable to parse Combined packet, could not create packet of type '{InnerPacketType}'");
					break;
				}
				basePacket.Receive(reader);
				Packets.Add(basePacket);
			}
		}
	}
	public class DamageFeedbackPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.DamageFeedback;

		public IdentifierData Target;

		public bool CausedByPlayer;

		public override PacketId TypeID => PacketId.DamageFeedback;

		public override Channel Channel => Channel.Player;

		public override void Send(Buffer writer)
		{
			writer.Write(Target);
			writer.Write(CausedByPlayer);
		}

		public override void Receive(Buffer reader)
		{
			Target = reader.ReadIdentifierData();
			CausedByPlayer = reader.ReadBoolean();
		}
	}
	public class DayNightPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.DayNight;

		public Timestate Timestate;

		public float NightLength;

		public override PacketId TypeID => PacketId.DayNight;

		public override Channel Channel => Channel.Game;

		public override void Send(Buffer writer)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			writer.Write((int)Timestate == 0);
			if ((int)Timestate == 0)
			{
				writer.Write(NightLength);
			}
		}

		public override void Receive(Buffer reader)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			Timestate = (Timestate)(!reader.ReadBoolean());
			if ((int)Timestate == 0)
			{
				NightLength = reader.ReadFloat();
			}
		}
	}
	public class EnemySpawnPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.EnemySpawn;

		public byte Wave;

		public byte Spawn;

		public ushort Id;

		public Vector3 Position;

		public byte Coins;

		public bool Elite;

		public override PacketId TypeID => PacketId.EnemySpawn;

		public override Channel Channel => Channel.Game;

		public override bool CanHandle(CSteamID sender)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return Plugin.Instance.Network.IsServer(sender);
		}

		public override void Send(Buffer writer)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(Wave);
			writer.Write(Spawn);
			writer.Write(Id);
			writer.Write(Position);
			writer.Write(Coins);
			writer.Write(Elite);
		}

		public override void Receive(Buffer reader)
		{
			//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)
			Wave = reader.ReadByte();
			Spawn = reader.ReadByte();
			Id = reader.ReadUInt16();
			Position = reader.ReadVector3();
			Coins = reader.ReadByte();
			Elite = reader.ReadBoolean();
		}
	}
	public class HostUnlocksPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.HostUnlocks;

		public List<Equipment> Unlocks = new List<Equipment>();

		public override PacketId TypeID => PacketId.HostUnlocks;

		public override Channel Channel => Channel.Game;

		public override void Send(Buffer writer)
		{
			writer.Write((byte)Unlocks.Count);
			foreach (Equipment unlock in Unlocks)
			{
				writer.Write(unlock);
			}
		}

		public override void Receive(Buffer reader)
		{
			byte b = reader.ReadByte();
			Unlocks.Clear();
			for (int i = 0; i < b; i++)
			{
				Unlocks.Add(reader.ReadEquipment());
			}
		}
	}
	public class LoadoutClosePacket : BasePacket
	{
		public const PacketId PacketID = PacketId.LoadoutClose;

		public override PacketId TypeID => PacketId.LoadoutClose;

		public override Channel Channel => Channel.Game;

		public override bool ShouldPropagate => true;

		public override void Send(Buffer writer)
		{
		}

		public override void Receive(Buffer reader)
		{
		}
	}
	public class LoadoutOpenPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.LoadoutOpen;

		public string Scene;

		public override PacketId TypeID => PacketId.LoadoutOpen;

		public override Channel Channel => Channel.Game;

		public override bool ShouldPropagate => true;

		public override void Send(Buffer writer)
		{
			writer.Write(Scene);
		}

		public override void Receive(Buffer reader)
		{
			Scene = reader.ReadString();
		}
	}
	public class LoadoutSelectionPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.LoadoutSelection;

		public List<Equipment> Selection = new List<Equipment>();

		public override PacketId TypeID => PacketId.LoadoutSelection;

		public override Channel Channel => Channel.Game;

		public override bool ShouldPropagate => true;

		public override void Send(Buffer writer)
		{
			writer.Write((byte)Selection.Count);
			foreach (Equipment item in Selection)
			{
				writer.Write(item);
			}
		}

		public override void Receive(Buffer reader)
		{
			byte b = reader.ReadByte();
			Selection.Clear();
			for (int i = 0; i < b; i++)
			{
				Selection.Add(reader.ReadEquipment());
			}
		}
	}
	public class LoadoutStateRequestPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.LoadoutStateRequest;

		public override PacketId TypeID => PacketId.LoadoutStateRequest;

		public override Channel Channel => Channel.Game;

		public override void Send(Buffer writer)
		{
		}

		public override void Receive(Buffer reader)
		{
		}
	}
	public class LoadoutWeaponPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.LoadoutWeapon;

		public ushort PlayerId;

		public Equipment Weapon;

		public override PacketId TypeID => PacketId.LoadoutWeapon;

		public override Channel Channel => Channel.Game;

		public override bool ShouldPropagate => true;

		public override void Send(Buffer writer)
		{
			writer.Write(PlayerId);
			writer.Write(Weapon);
		}

		public override void Receive(Buffer reader)
		{
			PlayerId = reader.ReadUInt16();
			Weapon = reader.ReadEquipment();
		}
	}
	public class LockTargetPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.LockTarget;

		public ushort PlayerId;

		public IdentifierData Target;

		public override PacketId TypeID => PacketId.LockTarget;

		public override Channel Channel => Channel.Game;

		public override bool ShouldPropagate => true;

		public override void Send(Buffer writer)
		{
			writer.Write(PlayerId);
			writer.Write(Target);
		}

		public override void Receive(Buffer reader)
		{
			PlayerId = reader.ReadUInt16();
			Target = reader.ReadIdentifierData();
		}
	}
	public class RequestLevelPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.RequestLevel;

		public string To;

		public string From;

		public Equipment SelectedWeapon;

		public List<Equipment> Perks = new List<Equipment>();

		public bool OverwriteSave;

		public override PacketId TypeID => PacketId.RequestLevel;

		public override Channel Channel => Channel.Game;

		public override void Send(Buffer writer)
		{
			writer.Write(To);
			writer.Write(From);
			writer.Write((byte)Perks.Count);
			foreach (Equipment perk in Perks)
			{
				writer.Write(perk);
			}
			writer.Write(OverwriteSave);
		}

		public override void Receive(Buffer reader)
		{
			To = reader.ReadString();
			From = reader.ReadString();
			byte b = reader.ReadByte();
			Perks.Clear();
			for (int i = 0; i < b; i++)
			{
				Perks.Add(reader.ReadEquipment());
			}
			OverwriteSave = reader.ReadBoolean();
		}
	}
	public class ResignPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.Resign;

		public override PacketId TypeID => PacketId.Resign;

		public override Channel Channel => Channel.Game;

		public override bool ShouldPropagate => true;

		public override void Send(Buffer writer)
		{
		}

		public override void Receive(Buffer reader)
		{
		}
	}
	public class RestartLevelPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.RestartLevel;

		public bool OverwriteSave;

		public override PacketId TypeID => PacketId.RestartLevel;

		public override Channel Channel => Channel.Game;

		public override void Send(Buffer writer)
		{
			writer.Write(OverwriteSave);
		}

		public override void Receive(Buffer reader)
		{
			OverwriteSave = reader.ReadBoolean();
		}
	}
	public class TeleportPlayerPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.TeleportPlayer;

		public ushort PlayerId;

		public Vector3 Position;

		public override PacketId TypeID => PacketId.TeleportPlayer;

		public override Channel Channel => Channel.SyncPositions;

		public override bool ShouldPropagate => true;

		public override void Send(Buffer writer)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(PlayerId);
			writer.Write(Position);
		}

		public override void Receive(Buffer reader)
		{
			//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)
			PlayerId = reader.ReadUInt16();
			Position = reader.ReadVector3();
		}
	}
	public class VictoryPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.Victory;

		public override PacketId TypeID => PacketId.Victory;

		public override Channel Channel => Channel.Game;

		public override bool ShouldPropagate => true;

		public override void Send(Buffer writer)
		{
		}

		public override void Receive(Buffer reader)
		{
		}
	}
	public class WeaponRequestPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.WeaponRequest;

		public override PacketId TypeID => PacketId.WeaponRequest;

		public override Channel Channel => Channel.Game;

		public override void Send(Buffer writer)
		{
		}

		public override void Receive(Buffer reader)
		{
		}
	}
	public class WeaponResponsePacket : BasePacket
	{
		public const PacketId PacketID = PacketId.WeaponResponse;

		public Equipment Weapon;

		public override PacketId TypeID => PacketId.WeaponResponse;

		public override Channel Channel => Channel.Game;

		public override void Send(Buffer writer)
		{
			writer.Write(Weapon);
		}

		public override void Receive(Buffer reader)
		{
			Weapon = reader.ReadEquipment();
		}
	}
}
namespace ThronefallMP.Network.Packets.Administration
{
	public class ApprovalPacket : BasePacket
	{
		public const PacketId PacketID = PacketId.Approval;

		public bool SameVersion;

		public string Password;

		public override PacketId TypeID => PacketId.Approval;

		public override Channel Channel => Channel.NetworkManagement;

		public override bool CanHandle(CSteamID sender)
		{
			return Plugin.Instance.Network.Server;
		}

		public override void Send(Buffer writer)
		{
			writer.Write("thronefall_mp_1.2.2");
			writer.Write(Password);
		}

		public override void Receive(Buffer reader)
		{
			Plugin.Log.LogInfo((object)"Reading version");
			SameVersion = reader.ReadString() == "thronefall_mp_1.2.2";
			Plugin.Log.LogInfo((object)"Reading password");
			Password = reader.ReadString();
		}
	}
	public class DisconnectPacket : BasePacket
	{
		public enum Reason
		{
			Kicked,
			WrongPassword,
			WrongVersion
		}

		public const PacketId PacketID = PacketId.Disconnect;

		public Reason DisconnectReason;

		public override PacketId TypeID => PacketId.Disconnect;

		public override Channel Channel => Channel.NetworkManagement;

		public override bool CanHandle(CSteamID sender)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return Plugin.Instance.Network.IsServer(sender);
		}

		public override void Send(Buffer writer)
		{
			Plugin.Log.LogInfo((object)$"Sending disconnect reason {DisconnectReason}");
			writer.Write((byte)DisconnectReason);
		}

		public override void Receive(Buffer reader)
		{
			DisconnectReason = (Reason)reader.ReadByte();
			Plugin.Log.LogInfo((object)$"Receiving disconnect reason {DisconnectReason}");
		}
	}
	public class PeerListPacket : BasePacket
	{
		public struct PlayerData
		{
			public ushort Id;

			public CSteamID SteamId;

			public byte SpawnId;

			public Vector3 Position;
		}

		public const PacketId PacketID = PacketId.PeerSync;

		public List<PlayerData> Players = new List<PlayerData>();

		public override PacketId TypeID => PacketId.PeerSync;

		public override Channel Channel => Channel.NetworkManagement;

		public override bool CanHandle(CSteamID sender)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return Plugin.Instance.Network.IsServer(sender);
		}

		public override void Send(Buffer writer)
		{
			//IL_003a: 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)
			writer.Write(Players.Count);
			foreach (PlayerData player in Players)
			{
				writer.Write(player.Id);
				writer.Write(player.SteamId);
				writer.Write(player.SpawnId);
				writer.Write(player.Position);
			}
		}

		public override void Receive(Buffer reader)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Players.Clear();
			int num = reader.ReadInt32();
			for (int i = 0; i < num; i++)
			{
				Players.Add(new PlayerData
				{
					Id = reader.ReadUInt16(),
					SteamId = reader.ReadSteamID(),
					SpawnId = reader.ReadByte(),
					Position = reader.ReadVector3()
				});
			}
		}
	}
}
namespace ThronefallMP.Components
{
	public enum IdentifierType
	{
		Invalid,
		Player,
		BuildSlot,
		Building,
		Ally,
		Enemy
	}
	public struct IdentifierData
	{
		public static readonly IdentifierData Invalid = new IdentifierData
		{
			Type = IdentifierType.Invalid,
			Id = 0
		};

		public IdentifierType Type;

		public ushort Id;

		public IdentifierData(Identifier identity)
		{
			Type = IdentifierType.Invalid;
			Id = 0;
			if ((Object)(object)identity != (Object)null)
			{
				Type = identity.Type;
				Id = identity.Id;
			}
		}

		public GameObject Get()
		{
			return Identifier.GetGameObject(Type, Id);
		}
	}
	public class Identifier : MonoBehaviour
	{
		private static readonly Dictionary<IdentifierType, HashSet<ushort>> DestroyedRepository = new Dictionary<IdentifierType, HashSet<ushort>>
		{
			{
				IdentifierType.Player,
				new HashSet<ushort>()
			},
			{
				IdentifierType.BuildSlot,
				new HashSet<ushort>()
			},
			{
				IdentifierType.Building,
				new HashSet<ushort>()
			},
			{
				IdentifierType.Ally,
				new HashSet<ushort>()
			},
			{
				IdentifierType.Enemy,
				new HashSet<ushort>()
			}
		};

		private static readonly Dictionary<IdentifierType, Dictionary<ushort, GameObject>> Repository = new Dictionary<IdentifierType, Dictionary<ushort, GameObject>>
		{
			{
				IdentifierType.Player,
				new Dictionary<ushort, GameObject>()
			},
			{
				IdentifierType.BuildSlot,
				new Dictionary<ushort, GameObject>()
			},
			{
				IdentifierType.Building,
				new Dictionary<ushort, GameObject>()
			},
			{
				IdentifierType.Ally,
				new Dictionary<ushort, GameObject>()
			},
			{
				IdentifierType.Enemy,
				new Dictionary<ushort, GameObject>()
			}
		};

		public IdentifierType Type { get; private set; }

		public ushort Id { get; private set; }

		public void OnDisable()
		{
			if (Type == IdentifierType.Player && (Object)(object)PlayerManager.Instance != (Object)null)
			{
				PlayerManager.UnregisterPlayer(((Component)this).GetComponent<PlayerMovement>());
			}
		}

		public void OnDestroy()
		{
			Repository[Type].Remove(Id);
			DestroyedRepository[Type].Add(Id);
		}

		public void SetIdentity(IdentifierType type, ushort id)
		{
			if (Repository[type].ContainsKey(id))
			{
				if (((Object)Repository[type][id]).GetInstanceID() == ((Object)((Component)this).gameObject).GetInstanceID())
				{
					return;
				}
				Plugin.Log.LogWarning((object)$"Identifier {type}:{id} already registered");
				Plugin.Log.LogInfo((object)(Helpers.GetPath(Repository[type][id].transform) ?? ""));
				Plugin.Log.LogInfo((object)(Helpers.GetPath(((Component)this).transform) ?? ""));
			}
			if (DestroyedRepository[type].Contains(id))
			{
				DestroyedRepository[type].Remove(id);
			}
			Type = type;
			Id = id;
			Repository[Type][Id] = ((Component)this).gameObject;
		}

		public static void Clear(IdentifierType type)
		{
			Repository[type].Clear();
		}

		public static GameObject GetGameObject(IdentifierType type, ushort id)
		{
			return (type == IdentifierType.Invalid) ? null : GeneralExtensions.GetValueSafe<ushort, GameObject>(Repository[type], id);
		}

		public static IEnumerable<(ushort id, GameObject target)> GetIdentifiers(IdentifierType type)
		{
			foreach (KeyValuePair<ushort, GameObject> pair in Repository[type])
			{
				if ((Object)(object)pair.Value != (Object)null)
				{
					yield return (id: pair.Key, target: pair.Value);
				}
			}
		}

		public static IEnumerable<GameObject> GetGameObjects(IdentifierType type)
		{
			foreach (KeyValuePair<ushort, GameObject> pair in Repository[type])
			{
				if ((Object)(object)pair.Value != (Object)null)
				{
					yield return pair.Value;
				}
			}
		}

		public static IEnumerable<ushort> GetDestroyed(IdentifierType type)
		{
			foreach (ushort item in DestroyedRepository[type])
			{
				yield return item;
			}
		}

		public static bool WasDestroyed(IdentifierType type, ushort id)
		{
			return DestroyedRepository[type].Contains(id);
		}

		public static void ClearDestroyed()
		{
			foreach (KeyValuePair<IdentifierType, HashSet<ushort>> item in DestroyedRepository)
			{
				item.Value.Clear();
			}
		}
	}
	public class LoadoutWatcher : MonoBehaviour
	{
		private bool _open;

		private bool _ready;

		private int _lastPlayerCount;

		private List<Equipment> _selectionSnapshot = new List<Equipment>();

		private Equipment _weaponSnapshot = Equipment.Invalid;

		private float _diagHeartbeat;

		private bool _lastOnline;

		private bool _lastInLevelSelect;

		private bool _lastPopupOpen;

		private void Update()
		{
			//IL_01df: 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_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: 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_02db: Unknown result type (might be due to invalid IL or missing references)
			ThronefallMP.Network.Network network = Plugin.Instance.Network;
			bool inLevelSelect = SceneTransitionManagerPatch.InLevelSelect;
			bool online = network.Online;
			bool popupOpen = LoadoutFrames.PopupOpen;
			if (online != _lastOnline || inLevelSelect != _lastInLevelSelect || popupOpen != _lastPopupOpen)
			{
				_lastOnline = online;
				_lastInLevelSelect = inLevelSelect;
				_lastPopupOpen = popupOpen;
				Plugin.Log.LogInfo((object)($"[LoadoutDiag] state online={online} inLevelSelect={inLevelSelect} " + $"popupOpen={popupOpen} _open={_open} {LoadoutFrames.DebugState()}"));
			}
			if (online || inLevelSelect)
			{
				_diagHeartbeat += Time.deltaTime;
				if (_diagHeartbeat >= 5f)
				{
					_diagHeartbeat = 0f;
					Plugin.Log.LogInfo((object)($"[LoadoutDiag] heartbeat online={online} inLevelSelect={inLevelSelect} " + $"popupOpen={popupOpen} _open={_open} server={network.Server} {LoadoutFrames.DebugState()}"));
				}
			}
			else
			{
				_diagHeartbeat = 0f;
			}
			if (!network.Online || !SceneTransitionManagerPatch.InLevelSelect)
			{
				_ready = false;
				if (_open)
				{
					_open = false;
					LoadoutStatusStrip.Hide();
					LoadoutState.Reset();
				}
				return;
			}
			if (!_ready)
			{
				_ready = true;
				if (!network.Server)
				{
					Plugin.Log.LogInfo((object)"[LoadoutDiag] ready, requesting loadout state");
					network.Send(new LoadoutStateRequestPacket());
				}
			}
			bool popupOpen2 = LoadoutFrames.PopupOpen;
			if (popupOpen2 && !_open)
			{
				OnOpened(network);
			}
			else if (!popupOpen2 && _open)
			{
				OnClosed(network);
			}
			_open = popupOpen2;
			if (!popupOpen2)
			{
				return;
			}
			int num = Plugin.Instance.PlayerManager.GetAllPlayers().Count();
			if (network.Server && _lastPlayerCount > 0 && num > _lastPlayerCount)
			{
				BroadcastOpen(network);
				BroadcastSelection(network);
				foreach (KeyValuePair<ushort, Equipment> weaponPick in LoadoutState.WeaponPicks)
				{
					network.Send(new LoadoutWeaponPacket
					{
						PlayerId = weaponPick.Key,
						Weapon = weaponPick.Value
					});
				}
			}
			_lastPlayerCount = num;
			var (list, equipment) = Capture();
			if (equipment != _weaponSnapshot)
			{
				_weaponSnapshot = equipment;
				LoadoutState.WeaponPicks[Plugin.Instance.PlayerManager.LocalId] = equipment;
				network.Send(new LoadoutWeaponPacket
				{
					PlayerId = Plugin.Instance.PlayerManager.LocalId,
					Weapon = equipment
				});
			}
			if (LoadoutState.SuppressNextDiff)
			{
				_selectionSnapshot = list;
				LoadoutState.SuppressNextDiff = false;
				UpdateStrip();
				return;
			}
			if (!list.SequenceEqual(_selectionSnapshot))
			{
				_selectionSnapshot = list;
				network.Send(new LoadoutSelectionPacket
				{
					Selection = new List<Equipment>(list)
				});
			}
			UpdateStrip();
		}

		private void OnOpened(ThronefallMP.Network.Network network)
		{
			CaptureSnapshot();
			_lastPlayerCount = Plugin.Instance.PlayerManager.GetAllPlayers().Count();
			LoadoutState.WeaponPicks[Plugin.Instance.PlayerManager.LocalId] = _weaponSnapshot;
			bool remoteOpenPending = LoadoutState.RemoteOpenPending;
			LoadoutState.RemoteOpenPending = false;
			LoadoutState.RemoteClosePending = false;
			Plugin.Log.LogInfo((object)($"[LoadoutDiag] open edge remote={remoteOpenPending} level=" + (((Object)(object)LevelInteractor.lastActiveLevelInfo != (Object)null) ? LevelInteractor.lastActiveLevelInfo.sceneName : "null")));
			if (remoteOpenPending)
			{
				BroadcastWeapon(network);
			}
			else
			{
				BroadcastOpen(network);
				BroadcastSelection(network);
				BroadcastWeapon(network);
			}
			LoadoutStatusStrip.Show();
			UpdateStrip();
		}

		private void OnClosed(ThronefallMP.Network.Network network)
		{
			//IL_0040: 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)
			bool remoteClosePending = LoadoutState.RemoteClosePending;
			LoadoutState.RemoteClosePending = false;
			LoadoutState.RemoteOpenPending = false;
			Plugin.Log.LogInfo((object)$"[LoadoutDiag] close edge remote={remoteClosePending}");
			if (!remoteClosePending)
			{
				network.Send(new LoadoutClosePacket());
			}
			LoadoutStatusStrip.Hide();
			LoadoutState.WeaponPicks.Clear();
			LoadoutState.SuppressNextDiff = false;
		}

		private void BroadcastOpen(ThronefallMP.Network.Network network)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			LevelInfo lastActiveLevelInfo = LevelInteractor.lastActiveLevelInfo;
			if ((Object)(object)lastActiveLevelInfo != (Object)null)
			{
				network.Send(new LoadoutOpenPacket
				{
					Scene = lastActiveLevelInfo.sceneName
				});
			}
		}

		private void BroadcastSelection(ThronefallMP.Network.Network network)
		{
			//IL_001b: 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)
			network.Send(new LoadoutSelectionPacket
			{
				Selection = new List<Equipment>(_selectionSnapshot)
			});
		}

		private void BroadcastWeapon(ThronefallMP.Network.Network network)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			network.Send(new LoadoutWeaponPacket
			{
				PlayerId = Plugin.Instance.PlayerManager.LocalId,
				Weapon = _weaponSnapshot
			});
		}

		private (List<Equipment> selection, Equipment weapon) Capture()
		{
			List<Equipment> list = new List<Equipment>();
			Equipment item = Equipment.Invalid;
			if ((Object)(object)PerkManager.instance != (Object)null)
			{
				foreach (Equippable item2 in PerkManager.instance.CurrentlyEquipped)
				{
					Equipment equipment = Equip.Convert(((Object)item2).name);
					if (equipment != Equipment.Invalid)
					{
						if (Equip.Weapons.Contains(equipment))
						{
							item = equipment;
						}
						else
						{
							list.Add(equipment);
						}
					}
				}
			}
			list.Sort();
			return (selection: list, weapon: item);
		}

		private void CaptureSnapshot()
		{
			(_selectionSnapshot, _weaponSnapshot) = Capture();
		}

		private void UpdateStrip()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			foreach (PlayerManager.Player allPlayer in Plugin.Instance.PlayerManager.GetAllPlayers())
			{
				string friendPersonaName = SteamFriends.GetFriendPersonaName(allPlayer.SteamID);
				LoadoutState.WeaponPicks.TryGetValue(allPlayer.Id, out var value);
				string text = "—";
				if (value != Equipment.Invalid)
				{
					Equippable val = Equip.Convert(value);
					text = (((Object)(object)val != (Object)null) ? val.displayName : value.ToString());
				}
				list.Add(friendPersonaName + ": " + text);
			}
			LoadoutStatusStrip.SetText(string.Join("   ·   ", list));
		}
	}
	public class MpFlagInteractor : MonoBehaviour
	{
		private Player _input;

		public GameObject Indicator { get; set; }

		public float InteractionDistance { get; set; }

		public void Start()
		{
			_input = ReInput.players.GetPlayer(0);
		}

		public void Update()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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)
			PlayerNetworkData playerNetworkData = Plugin.Instance.PlayerManager.LocalPlayer?.Data;
			if (!((Object)(object)playerNetworkData == (Object)null))
			{
				Vector3 position = ((Component)playerNetworkData).transform.position;
				Vector3 val = position - ((Component)this).transform.position;
				bool flag = ((Vector3)(ref val)).sqrMagnitude <= InteractionDistance * InteractionDistance;
				Indicator.SetActive(flag);
				if (flag && !LocalGamestate.Instance.PlayerFrozen && !_input.GetButtonDown("Interact"))
				{
				}
			}
		}
	}
	public class PlayerLabelFollower : MonoBehaviour
	{
		private TextMeshPro _text;

		private Camera _camera;

		private Vector3 _offset;

		public int TargetPlayer { get; set; }

		private void Start()
		{
			//IL_0056: 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_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_00bc: Unknown result type (might be due to invalid IL or missing references)
			_camera = Camera.main;
			_text = ((Component)this).GetComponent<TextMeshPro>();
			((TMP_Text)_text).fontSize = 12f;
			((TMP_Text)_text).fontMaterial.EnableKeyword(ShaderUtilities.Keyword_Outline);
			((TMP_Text)_text).alignment = (TextAlignmentOptions)514;
			((Graphic)_text).color = Color.white;
			((TMP_Text)_text).outlineColor = Color32.op_Implicit(Color.black);
			((TMP_Text)_text).outlineWidth = 0.2f;
			_offset = new Vector3(0.15f, 6f, -0.15f);
			_text.transform.rotation = Quaternion.Euler(54.17f, 45.09f, 0f);
			RefreshText();
		}

		private void Update()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0077: Unknown result type (might be due to invalid IL or missing references)
			PlayerManager.Player player = Plugin.Instance.PlayerManager.Get(TargetPlayer);
			if (player == null || (Object)(object)player.Object == (Object)null)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else
			{
				_text.transform.position = Vector3.Lerp(_text.transform.position, player.Object.transform.position + _offset, 0.7f);
			}
		}

		private void RefreshText()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			PlayerManager.Player player = Plugin.Instance.PlayerManager.Get(TargetPlayer);
			if (SteamManager.Initialized && player != null)
			{
				((TMP_Text)_text).text = SteamFriends.GetFriendPersonaName(player.SteamID);
				Plugin.Log.LogInfo((object)$"Found name for {player.Id} = '{((TMP_Text)_text).text}'");
			}
		}
	}
	public class PlayerNetworkData : MonoBehaviour
	{
		public class Shared
		{
			public float MoveHorizontal;

			public float MoveVertical;

			public bool SprintToggleButton;

			public bool SprintButton;

			public bool InteractButton;

			public bool CallNightButton;

			public float CallNightFill;

			public bool CommandUnitsButton;

			public bool Slowed;

			public bool SelectAllArmy;

			public bool SelectAllMelee;

			public bool SelectAllRanged;

			public bool SelectAllHeroes;

			public void Set(Shared a)
			{
				MoveHorizontal = a.MoveHorizontal;
				MoveVertical = a.MoveVertical;
				SprintToggleButton = a.SprintToggleButton;
				SprintButton = a.SprintButton;
				InteractButton = a.InteractButton;
				CallNightButton = a.CallNightButton;
				CallNightFill = a.CallNightFill;
				CommandUnitsButton = a.CommandUnitsButton;
				Slowed = a.Slowed;
				SelectAllArmy = a.SelectAllArmy;
				SelectAllMelee = a.SelectAllMelee;
				SelectAllRanged = a.SelectAllRanged;
				SelectAllHeroes = a.SelectAllHeroes;
			}

			public bool Compare(Shared b)
			{
				return Math.Abs(MoveHorizontal - b.MoveHorizontal) < 1.8E-43f && Math.Abs(MoveVertical - b.MoveVertical) < 1.8E-43f && SprintToggleButton == b.SprintToggleButton && SprintButton == b.SprintButton && InteractButton == b.InteractButton && CallNightButton == b.CallNightButton && Math.Abs(CallNightFill - b.CallNightFill) < 1.8E-43f && CommandUnitsButton == b.CommandUnitsButton && Slowed == b.Slowed && SelectAllArmy == b.SelectAllArmy && SelectAllMelee == b.SelectAllMelee && SelectAllRanged == b.SelectAllRanged && SelectAllHeroes == b.SelectAllHeroes;
			}
		}

		public ushort id;

		public PlayerManager.Player Player;

		public Shared SharedData = new Shared();

		public bool IsLocal => Plugin.Instance.PlayerManager.LocalId == id;

		public bool PlayerMovementSprintLast { get; set; }

		public bool PlayerScepterInteractLast { get; set; }

		public bool CallNightLast { get; set; }

		public bool CommandUnitsButtonLast { get; set; }

		public bool SelectAllArmyLast { get; set; }

		public bool SelectAllMeleeLast { get; set; }

		public bool SelectAllRangedLast { get; set; }

		public bool SelectAllHeroesLast { get; set; }

		private void Update()
		{
			if (IsLocal)
			{
				bool playerFrozen = LocalGamestate.Instance.PlayerFrozen;
				Player player = ReInput.players.GetPlayer(0);
				SharedData.MoveHorizontal = (playerFrozen ? 0f : player.GetAxis("Move Horizontal"));
				SharedData.MoveVertical = (playerFrozen ? 0f : player.GetAxis("Move Vertical"));
				SharedData.SprintToggleButton = !playerFrozen && player.GetButton("Sprint Toggle");
				SharedData.SprintButton = !playerFrozen && player.GetButton("Sprint");
				SharedData.InteractButton = !playerFrozen && player.GetButton("Interact");
				SharedData.CallNightButton = !playerFrozen && player.GetButton("Call Night");
				SharedData.CallNightFill = (playerFrozen ? 0f : Traverse.Create((object)NightCall.instance).Field<float>("currentFill").Value);
				SharedData.CommandUnitsButton = !playerFrozen && player.GetButton("Command Units");
				SharedData.SelectAllArmy = !playerFrozen && player.GetButton("Select All Army");
				SharedData.SelectAllMelee = !playerFrozen && player.GetButton("Select All Melee");
				SharedData.SelectAllRanged = !playerFrozen && player.GetButton("Select All Ranged");
				SharedData.SelectAllHeroes = !playerFrozen && player.GetButton("Select All Heroes");
			}
		}
	}
	public class PositionErrorSmoother : MonoBehaviour
	{
		public float K = 12f;

		private Vector3 _pendingError;

		public void ApplyCorrection(Vector3 hostPosition, float snapDistance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			Vector3 pendingError = hostPosition - ((Component)this).transform.position;
			if (((Vector3)(ref pendingError)).sqrMagnitude > snapDistance * snapDistance)
			{
				((Component)this).transform.position = hostPosition;
				_pendingError = Vector3.zero;
			}
			else
			{
				_pendingError = pendingError;
			}
		}

		private void LateUpdate()
		{
			//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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0085: Unknown result type (might be due to invalid IL or missing references)
			if (!(_pendingError == Vector3.zero))
			{
				float num = 1f - Mathf.Exp((0f - K) * Time.deltaTime);
				Vector3 val = _pendingError * num;
				Transform transform = ((Component)this).transform;
				transform.position += val;
				_pendingError -= val;
				if (((Vector3)(ref _pendingError)).sqrMagnitude < 1E-06f)
				{
					_pendingError = Vector3.zero;
				}
			}
		}
	}
	public class TweenScale : MonoBehaviour
	{
		private bool _tweening;

		private Vector3 _start;

		private Vector3 _end;

		private float _actualDuration;

		private float _duration;

		private float _bounce;

		private float _timer;

		private void Update()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			if (!_tweening)
			{
				return;
			}
			_timer += Time.unscaledDeltaTime;
			if (_timer >= _actualDuration)
			{
				_tweening = false;
				((Component)this).transform.localScale = _end;
				return;
			}
			float num = Mathf.Min(_timer / _duration, 1f + _bounce * 2f);
			if (num > 1f + _bounce)
			{
				num = 2f + 2f * _bounce - num;
			}
			((Component)this).transform.localScale = Vector3.LerpUnclamped(_start, _end, num);
		}

		public void Tween(Vector3 target, float duration, float bounce = 0f)
		{
			//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_001b: Unknown result type (might be due to invalid IL or missing references)
			_tweening = true;
			_start = ((Component)this).transform.localScale;
			_end = target;
			_bounce = bounce;
			_actualDuration = duration;
			_duration = duration / (1f + 2f * _bounce);
			_timer = 0f;
		}

		public void Stop()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			_tweening = false;
			((Component)this).transform.localScale = _end;
		}
	}
}