using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.NetworkInformation;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Threading;
using AILimitCoop.Dev;
using AILimitCoop.Game;
using AILimitCoop.Net;
using AILimitCoop.UI;
using AILimitCoop.Util;
using ArchiveDef;
using BehaviorDesigner.Runtime;
using BehaviorDesigner.Runtime.Tasks;
using BehaviorDesigner.Runtime.Tasks.Unity.Math;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.UnityEngine;
using GameDef;
using HarmonyLib;
using Il2CppInterop.Common.XrefScans;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Reflection;
using LevelEdit;
using LiteNetLib;
using LiteNetLib.Layers;
using LiteNetLib.Utils;
using Microsoft.CodeAnalysis;
using PlayerShowSateDefine;
using RootMotion.Dynamics;
using SceneSettingDef;
using SenseGame;
using SenseGame.Tasks;
using Steamworks;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Samples;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.ResourceManagement.AsyncOperations;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("AILimitCoop contributors")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.2.4.0")]
[assembly: AssemblyInformationalVersion("0.2.4")]
[assembly: AssemblyProduct("AI LIMIT Co-op")]
[assembly: AssemblyTitle("AILimitCoop")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace AILimitCoop
{
	public enum PartyHudCorner
	{
		TopRight,
		TopLeft,
		BottomRight,
		BottomLeft
	}
	public enum TransportKind
	{
		UDP,
		Steam
	}
	public enum HitDetectionMode
	{
		Auto,
		ClientSide,
		HostForward
	}
	public static class CoopConfig
	{
		public static ConfigEntry<string> PlayerName;

		public static ConfigEntry<TransportKind> Transport;

		public static ConfigEntry<int> Port;

		public static ConfigEntry<string> JoinAddress;

		public static ConfigEntry<int> MaxPlayers;

		public static ConfigEntry<KeyCode> ToggleMenuKey;

		public static ConfigEntry<KeyCode> HostKey;

		public static ConfigEntry<KeyCode> JoinKey;

		public static ConfigEntry<KeyCode> LeaveKey;

		public static ConfigEntry<float> PlayerSendRate;

		public static ConfigEntry<float> MonsterSendRate;

		public static ConfigEntry<float> NetworkDiagnosticsInterval;

		public static ConfigEntry<float> InterpolationDelay;

		public static ConfigEntry<float> GhostAnimSmoothing;

		public static ConfigEntry<float> GhostAnimCrossFade;

		public static ConfigEntry<bool> SyncMonsters;

		public static ConfigEntry<float> EnemyHpPerExtraPlayer;

		public static ConfigEntry<bool> GhostTargeting;

		public static ConfigEntry<HitDetectionMode> HitDetection;

		public static ConfigEntry<bool> GhostEquipment;

		public static ConfigEntry<bool> GhostCollision;

		public static ConfigEntry<bool> ForceRunInBackground;

		public static ConfigEntry<bool> EnableOverlay;

		public static ConfigEntry<bool> ShowHud;

		public static ConfigEntry<float> HudScale;

		public static ConfigEntry<float> HudOpacity;

		public static ConfigEntry<PartyHudCorner> HudCorner;

		public static ConfigEntry<bool> AllyHealthBars;

		public static ConfigEntry<float> AllyHealthBarDistance;

		public static ConfigEntry<bool> AllyHealthBarNames;

		public static ConfigEntry<bool> ShowChat;

		public static ConfigEntry<KeyCode> ChatKey;

		public static ConfigEntry<bool> ShowMenuOnStart;

		public const string DefaultPlayerName = "Player";

		public static ConfigEntry<bool> Verbose;

		public static ConfigEntry<bool> DevCommands;

		public static ConfigEntry<string> PatchGroups;

		public static ConfigEntry<int> SimulatedLatencyMs;

		public static ConfigEntry<int> SimulatedJitterMs;

		public static ConfigEntry<int> SimulatedPacketLossPercent;

		public static int EffectivePort
		{
			get
			{
				if (InstanceProfile.Port <= 0)
				{
					return Port.Value;
				}
				return InstanceProfile.Port;
			}
		}

		public static string EffectivePlayerName
		{
			get
			{
				if (!string.IsNullOrEmpty(InstanceProfile.PlayerName))
				{
					return InstanceProfile.PlayerName;
				}
				string text = PlayerName?.Value;
				if (!string.IsNullOrWhiteSpace(text) && text != "Player")
				{
					return text;
				}
				string localName = SteamPresence.LocalName;
				if (!string.IsNullOrWhiteSpace(localName))
				{
					return localName;
				}
				return "Player";
			}
		}

		public static void Bind(ConfigFile cfg)
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Expected O, but got Unknown
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Expected O, but got Unknown
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Expected O, but got Unknown
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Expected O, but got Unknown
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Expected O, but got Unknown
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Expected O, but got Unknown
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_051a: Expected O, but got Unknown
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_054a: Expected O, but got Unknown
			//IL_056d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0577: Expected O, but got Unknown
			PlayerName = cfg.Bind<string>("General", "PlayerName", DefaultName(), "Name shown to other players.");
			Transport = cfg.Bind<TransportKind>("General", "Transport", TransportKind.UDP, "UDP: connect by IP address (LAN, VPN such as ZeroTier/Radmin/Hamachi, or a forwarded port).\nSteam: experimental peer-to-peer over Steam; requires the host and clients to be Steam friends.");
			Port = cfg.Bind<int>("General", "Port", 7777, "UDP port to host on (and default port when joining).");
			JoinAddress = cfg.Bind<string>("General", "JoinAddress", "127.0.0.1:7777", "Address used by the Join key / menu. UDP: ip:port. Steam: the host's 64-bit Steam id.");
			MaxPlayers = cfg.Bind<int>("General", "MaxPlayers", 8, new ConfigDescription("Maximum players in a hosted session, including the host. More than two is experimental; up to 16 allowed for stress testing.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(2, 16), Array.Empty<object>()));
			ToggleMenuKey = cfg.Bind<KeyCode>("Keys", "ToggleMenu", (KeyCode)286, "Show/hide the co-op menu.");
			HostKey = cfg.Bind<KeyCode>("Keys", "Host", (KeyCode)287, "Start hosting a session.");
			JoinKey = cfg.Bind<KeyCode>("Keys", "Join", (KeyCode)288, "Join the session at JoinAddress.");
			LeaveKey = cfg.Bind<KeyCode>("Keys", "Leave", (KeyCode)289, "Leave / stop the current session.");
			PlayerSendRate = cfg.Bind<float>("Network", "PlayerSendRate", 30f, new ConfigDescription("How many times per second your character state is sent.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 60f), Array.Empty<object>()));
			MonsterSendRate = cfg.Bind<float>("Network", "MonsterSendRate", 15f, new ConfigDescription("Host only: how many times per second monster states are sent.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 30f), Array.Empty<object>()));
			NetworkDiagnosticsInterval = cfg.Bind<float>("Network", "DiagnosticsInterval", 30f, new ConfigDescription("Seconds between networking summaries in LogOutput.log. 0 disables periodic summaries; counters and rate-limited send failures remain active.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 300f), Array.Empty<object>()));
			InterpolationDelay = cfg.Bind<float>("Network", "InterpolationDelay", 0.1f, new ConfigDescription("Seconds of buffering applied to remote characters. Higher is smoother but adds visual latency.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 0.5f), Array.Empty<object>()));
			GhostAnimSmoothing = cfg.Bind<float>("Network", "GhostAnimSmoothing", 0.08f, "Seconds of easing applied to another player's animation blending. Updates arrive at the send rate, so writing them straight through makes movement look stepped. 0 disables.");
			GhostAnimCrossFade = cfg.Bind<float>("Network", "GhostAnimCrossFade", 0.06f, "Seconds to fade when another player's animation state changes, instead of cutting. 0 disables.");
			SyncMonsters = cfg.Bind<bool>("Gameplay", "SyncMonsters", true, "Share monsters in the host's level. Nearby players simulate enemies with ownership locked during combat. Disable for 'ghost only' mode where everyone fights their own monsters.");
			EnemyHpPerExtraPlayer = cfg.Bind<float>("Gameplay", "EnemyHpPerExtraPlayer", 0.5f, new ConfigDescription("Host setting, shared when players join. Extra enemy and boss HP per additional connected player: 0.5 = +50%, 0 disables. Includes spectators and players in other areas. Combat locks the maximum until rest/reset. Change before hosting a new session.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			GhostTargeting = cfg.Bind<bool>("Gameplay", "GhostTargeting", true, "The enemy simulator evaluates living players using damage, proximity, threat decay and safe target changes.");
			HitDetection = cfg.Bind<HitDetectionMode>("Gameplay", "HitDetection", HitDetectionMode.Auto, "How monster attacks against remote players are resolved. Leave on Auto unless you know what you are doing.");
			GhostEquipment = cfg.Bind<bool>("Gameplay", "GhostEquipment", true, "Show other players' armor and weapons on their ghosts (disable if ghosts fail to spawn).");
			GhostCollision = cfg.Bind<bool>("Gameplay", "GhostCollision", false, "Keep the character controller on ghosts so players physically block each other.");
			ForceRunInBackground = cfg.Bind<bool>("General", "ForceRunInBackground", true, "Keep simulating while the game window is not focused. Needed so your character keeps syncing when you\nalt-tab, and required to run two instances on one PC.");
			EnableOverlay = cfg.Bind<bool>("UI", "EnableOverlay", true, "Draw the in-game menu and HUD. Turn off if the overlay causes problems; hotkeys and the config file still work.");
			ShowHud = cfg.Bind<bool>("UI", "ShowHud", true, "Show the party cards while the co-op menu is closed.");
			HudScale = cfg.Bind<float>("UI", "HudScale", 1f, new ConfigDescription("Party HUD size, relative to automatic resolution scaling.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.75f, 1.5f), Array.Empty<object>()));
			HudOpacity = cfg.Bind<float>("UI", "HudOpacity", 0.9f, new ConfigDescription("Party HUD panel opacity. Text and health remain readable.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.35f, 1f), Array.Empty<object>()));
			HudCorner = cfg.Bind<PartyHudCorner>("UI", "HudCorner", PartyHudCorner.TopRight, "Screen corner used by the party HUD.");
			AllyHealthBars = cfg.Bind<bool>("UI", "AllyHealthBars", true, "Show a small health bar above allies in your area. Hidden while the co-op menu is open and whenever the game hides its own enemy health bars.");
			AllyHealthBarDistance = cfg.Bind<float>("UI", "AllyHealthBarDistance", 40f, new ConfigDescription("Metres from the camera beyond which allies show no bar. Bars shrink with distance and fade out near this limit.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 100f), Array.Empty<object>()));
			AllyHealthBarNames = cfg.Bind<bool>("UI", "AllyHealthBarNames", true, "Show each ally's name above their health bar. Names fade out at a shorter distance than the bar.");
			ShowChat = cfg.Bind<bool>("UI", "ShowChat", true, "Show party chat and allow typing messages. Messages fade after a few seconds while chat is closed.");
			ChatKey = cfg.Bind<KeyCode>("Keys", "Chat", (KeyCode)13, "Open party chat while in a session. Enter sends and Escape closes; other co-op hotkeys pause while you type.");
			ShowMenuOnStart = cfg.Bind<bool>("UI", "ShowMenuOnStart", true, "Show the co-op menu when the game starts.");
			Verbose = cfg.Bind<bool>("Debug", "Verbose", false, "Log per-hit and per-spawn diagnostics to BepInEx/LogOutput.log.");
			DevCommands = cfg.Bind<bool>("Debug", "DevCommands", false, "Poll <GameDir>/BepInEx/coop_cmd.txt for developer commands (host, join, leave, dump, ...). Development aid only.");
			PatchGroups = cfg.Bind<string>("Debug", "PatchGroups", "Lifecycle,Ghost,Monster,Hit,Overlay", "Which groups of game hooks to install (comma separated). Troubleshooting aid: remove a group to disable that feature.\nLifecycle = level/game start tracking, Ghost = remote player bodies, Monster = shared monster simulation,\nHit = damage relay and targeting, Overlay = in-game menu/HUD drawing.");
			SimulatedLatencyMs = cfg.Bind<int>("Debug", "SimulatedLatencyMs", 0, new ConfigDescription("Testing aid: delay every packet this many milliseconds each way. 0 is off.\nA typical distant player sits around 30-80. Leave at 0 for real play.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 500), Array.Empty<object>()));
			SimulatedJitterMs = cfg.Bind<int>("Debug", "SimulatedJitterMs", 0, new ConfigDescription("Testing aid: vary the simulated delay by up to this much, so packets arrive unevenly.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 200), Array.Empty<object>()));
			SimulatedPacketLossPercent = cfg.Bind<int>("Debug", "SimulatedPacketLossPercent", 0, new ConfigDescription("Testing aid: drop this percentage of outgoing packets. 0 is off.\n1-3 resembles a poor connection and is the case worth testing.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 50), Array.Empty<object>()));
		}

		private static string DefaultName()
		{
			return "Player";
		}
	}
	public sealed class KeyEdge
	{
		private readonly Dictionary<KeyCode, bool> _held = new Dictionary<KeyCode, bool>();

		private static readonly int _pid = Process.GetCurrentProcess().Id;

		[DllImport("user32.dll")]
		private static extern short GetAsyncKeyState(int vKey);

		public static bool MouseButtonHeld()
		{
			if ((GetAsyncKeyState(1) & 0x8000) == 0 && (GetAsyncKeyState(2) & 0x8000) == 0)
			{
				return (GetAsyncKeyState(4) & 0x8000) != 0;
			}
			return true;
		}

		[DllImport("user32.dll")]
		private static extern IntPtr GetForegroundWindow();

		[DllImport("user32.dll")]
		private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);

		public static bool GameHasFocus()
		{
			try
			{
				IntPtr foregroundWindow = GetForegroundWindow();
				if (foregroundWindow == IntPtr.Zero)
				{
					return false;
				}
				GetWindowThreadProcessId(foregroundWindow, out var processId);
				return processId == (uint)_pid;
			}
			catch
			{
				return true;
			}
		}

		public static int ToVirtualKey(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Expected I4, but got Unknown
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between Unknown and I4
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Invalid comparison between Unknown and I4
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Invalid comparison between Unknown and I4
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Invalid comparison between Unknown and I4
			//IL_00a4: 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_00d1: Expected I4, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Invalid comparison between Unknown and I4
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Invalid comparison between Unknown and I4
			//IL_0119: 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_0149: Expected I4, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected I4, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Invalid comparison between Unknown and I4
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Invalid comparison between Unknown and I4
			//IL_0149: 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_0179: Expected I4, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Invalid comparison between Unknown and I4
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Invalid comparison between Unknown and I4
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Invalid comparison between Unknown and I4
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			int num = (int)key;
			if ((int)key >= 282 && (int)key <= 296)
			{
				return 112 + (num - 282);
			}
			if ((int)key >= 97 && (int)key <= 122)
			{
				return 65 + (num - 97);
			}
			if ((int)key >= 48 && (int)key <= 57)
			{
				return 48 + (num - 48);
			}
			if ((int)key >= 256 && (int)key <= 265)
			{
				return 96 + (num - 256);
			}
			if ((int)key <= 32)
			{
				if ((int)key <= 13)
				{
					if ((int)key == 8)
					{
						return 8;
					}
					if ((int)key == 9)
					{
						return 9;
					}
					if ((int)key == 13)
					{
						return 13;
					}
				}
				else
				{
					if ((int)key == 19)
					{
						return 19;
					}
					if ((int)key == 27)
					{
						return 27;
					}
					if ((int)key == 32)
					{
						return 32;
					}
				}
			}
			else if ((int)key <= 61)
			{
				switch (key - 39)
				{
				default:
					if ((int)key != 59)
					{
						if ((int)key != 61)
						{
							break;
						}
						return 187;
					}
					return 186;
				case 6:
					return 189;
				case 0:
					return 222;
				case 5:
					return 188;
				case 7:
					return 190;
				case 8:
					return 191;
				case 1:
				case 2:
				case 3:
				case 4:
					break;
				}
			}
			else if ((int)key <= 127)
			{
				switch (key - 91)
				{
				default:
					if ((int)key != 127)
					{
						break;
					}
					return 46;
				case 5:
					return 192;
				case 0:
					return 219;
				case 2:
					return 221;
				case 1:
					return 220;
				case 3:
				case 4:
					break;
				}
			}
			else
			{
				switch (key - 273)
				{
				case 7:
					return 33;
				case 8:
					return 34;
				case 6:
					return 35;
				case 5:
					return 36;
				case 3:
					return 37;
				case 0:
					return 38;
				case 2:
					return 39;
				case 1:
					return 40;
				case 4:
					return 45;
				}
				switch (key - 300)
				{
				case 1:
					return 20;
				case 0:
					return 144;
				case 2:
					return 145;
				case 4:
					return 160;
				case 3:
					return 161;
				case 6:
					return 162;
				case 5:
					return 163;
				case 8:
					return 164;
				case 7:
					return 165;
				}
			}
			return 0;
		}

		public bool Pressed(KeyCode key)
		{
			//IL_0002: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			try
			{
				int num = ToVirtualKey(key);
				if (num != 0)
				{
					flag = (GetAsyncKeyState(num) & 0x8000) != 0;
				}
			}
			catch
			{
			}
			bool value;
			bool flag2 = _held.TryGetValue(key, out value) && value;
			_held[key] = flag;
			if (flag)
			{
				return !flag2;
			}
			return false;
		}

		public bool Held(KeyCode key)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			bool value;
			return _held.TryGetValue(key, out value) && value;
		}
	}
	public sealed class CoopRuntime
	{
		public readonly Session Session;

		public readonly RemotePlayerManager Ghosts;

		public readonly MonsterSyncHost MonsterHost;

		public readonly MonsterSyncClient MonsterClient;

		public readonly MonsterAuthority Authority;

		public readonly EnemyHealthScaling HealthScaling;

		public readonly LocalPlayerSampler Sampler = new LocalPlayerSampler();

		public readonly MonsterIndex MonsterIndex = new MonsterIndex();

		public readonly CoopUI UI;

		public readonly MenuInputFocus MenuFocus;

		public readonly BossRewardSync Rewards;

		public readonly PartyLife Life;

		public readonly MonsterThreat Threat;

		public readonly SharedWorld World;

		public readonly DevCommands Dev;

		private readonly KeyEdge _keys = new KeyEdge();

		private int _levelId = -1;

		private bool _loading;

		private float _nextStateSend;

		private float _nextEquipCheck;

		private PlayerEquipMsg _lastEquip;

		private bool _equipSent;

		private float _lastErrorAt;

		private int _errorBurst;

		private RemotePlayer _fakeGhost;

		private Peer _fakePeer;

		private float _nextFakeSend;

		private readonly PlayerStateMsg _fakeState = new PlayerStateMsg();

		public bool MenuVisible;

		private int _frames;

		private readonly SessionPerformance _performance = new SessionPerformance();

		private int _hostAttempts;

		private float _nextHostAttempt;

		private bool _firstGui = true;

		private int _guiCalls;

		private float _nextAutoContinue;

		private int _autoContinueAttempts;

		private bool _autoStarted;

		private float _autoStartAt = -1f;

		private float _autoRetryAt;

		private int _autoRetries;

		private bool _steamLaunchJoinChecked;

		private Action _frameAction;

		private float _frameActionUntil;

		private Action _delayedAction;

		private float _delayedAt;

		public static CoopRuntime Instance { get; private set; }

		public int LevelId => _levelId;

		public bool Loading => _loading;

		public string LastError { get; private set; } = "";

		public bool GameActive { get; private set; }

		public bool OverlayAvailable => OverlayHost.IsAlive;

		public bool FakeGhostActive => _fakeGhost != null;

		public static void Create()
		{
			Instance = new CoopRuntime();
			HitRelay.Runtime = Instance;
		}

		private CoopRuntime()
		{
			Log.Trace("runtime ctor: begin");
			Session = new Session(new SteamBanList(Path.Combine(Paths.ConfigPath, "com.ailimit.coop.bans" + InstanceProfile.FileSuffix + ".json")));
			Session.Diagnostics.SummaryInterval = CoopConfig.NetworkDiagnosticsInterval.Value;
			Ghosts = new RemotePlayerManager(Session);
			Authority = new MonsterAuthority(Session);
			HealthScaling = new EnemyHealthScaling(Session, Authority);
			MonsterHost = new MonsterSyncHost(Session, Authority, HealthScaling);
			MonsterClient = new MonsterSyncClient(Session, Authority, HealthScaling, MonsterIndex);
			Log.Trace("runtime ctor: sync objects");
			UI = new CoopUI(this);
			MenuFocus = new MenuInputFocus(this);
			Rewards = new BossRewardSync(this);
			Life = new PartyLife(this);
			Threat = new MonsterThreat(this);
			World = new SharedWorld(this);
			MonsterClient.ActivationTarget = Threat.RecoveryTarget;
			Dev = new DevCommands(this);
			Log.Trace("runtime ctor: ui/dev");
			MenuVisible = CoopConfig.ShowMenuOnStart.Value;
			Session.OnMonsterHit += HitRelay.ApplyMonsterHit;
			Session.OnGhostHit += HitRelay.ApplyGhostHit;
			Session.OnPeerJoined += delegate(Peer p)
			{
				_equipSent = false;
				UI.Notify(p.Name + " joined", $"{p} joined");
			};
			Session.OnPeerLeft += delegate(Peer p)
			{
				UI.Notify(p.Name + " left", $"{p} left");
			};
			Session.OnChat += delegate(Peer p, string text)
			{
				UI.ReceiveChat(p, text);
			};
			Session.OnSessionStarted += delegate
			{
				_equipSent = false;
				HitRelay.ClientSideHitsObserved = false;
				UI.Notify(Session.IsHost ? "Hosting session" : "Joining session...");
			};
			Session.OnSessionEnded += delegate(string reason)
			{
				HitRelay.ClearCaches();
				UI.ClearChat();
				UI.Notify("Session ended: " + reason);
			};
		}

		private void EnsureHost(float now)
		{
			if (!OverlayHost.IsAlive && CoopConfig.EnableOverlay.Value && !(now < _nextHostAttempt) && _hostAttempts < 3)
			{
				_hostAttempts++;
				_nextHostAttempt = now + 5f;
				Log.Trace("host: creating");
				if (OverlayHost.TryCreate())
				{
					Log.Trace("host: ready");
				}
				else
				{
					Log.Trace("host: failed");
				}
			}
		}

		public void Update()
		{
			bool flag = _frames < 3;
			if (flag)
			{
				Log.Trace($"Update {_frames} begin");
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			_frames++;
			_performance.Begin(this, realtimeSinceStartup);
			try
			{
				if (_frames == 1)
				{
					Log.Info("[Coop] first Update");
				}
				if (_frames > 1)
				{
					EnsureHost(realtimeSinceStartup);
				}
				GhostRegistry.Prune(Time.frameCount, realtimeSinceStartup);
				if (flag)
				{
					Log.Trace("Update: keys");
				}
				if (KeyEdge.GameHasFocus())
				{
					HandleKeys();
				}
				MenuFocus.Tick();
				SteamPresence.Tick(realtimeSinceStartup, MenuVisible);
				if (flag)
				{
					Log.Trace("Update: dev poll");
				}
				Dev.Poll(realtimeSinceStartup);
				if (flag)
				{
					Log.Trace("Update: session poll");
				}
				if (GameActive)
				{
					TrackLevel();
				}
				_performance.Mark(CoopWork.Input);
				Session.Poll();
				_performance.Mark(CoopWork.Network);
				CoopMenuPause.Tick(this);
				Life.Tick(realtimeSinceStartup);
				ChestInteractionSafety.Tick(GameActive && !Loading && Session.IsConnected);
				_performance.Mark(CoopWork.Life);
				if (!GameActive)
				{
					_levelId = -1;
					_loading = true;
					AutoContinueTick(realtimeSinceStartup);
					SendState(realtimeSinceStartup);
					if (flag)
					{
						Log.Trace("Update end (inactive)");
					}
					return;
				}
				TrackLevel();
				AutoStart(realtimeSinceStartup);
				PumpFrameAction(realtimeSinceStartup);
				UpdateFakeGhost(realtimeSinceStartup);
				if (Session.IsActive || _fakeGhost != null)
				{
					Sampler.Bind(GameState.LocalPlayer);
					SendState(realtimeSinceStartup);
					_performance.Mark(CoopWork.LocalState);
					World.Tick(realtimeSinceStartup);
					Ghosts.Update(realtimeSinceStartup, _levelId, _loading);
					_performance.Mark(CoopWork.Ghosts);
					MonsterHost.Tick(realtimeSinceStartup, _levelId, _loading);
					_performance.Mark(CoopWork.MonsterSend);
					MonsterClient.Update(realtimeSinceStartup, _levelId);
					_performance.Mark(CoopWork.MonsterReceive);
					Threat.Tick(realtimeSinceStartup);
					_performance.Mark(CoopWork.Threat);
					Rewards.Tick();
					_performance.Mark(CoopWork.Rewards);
				}
			}
			catch (Exception ex)
			{
				ReleaseMenuOnError();
				ReportError("Update", ex);
			}
			finally
			{
				_performance.End(this, realtimeSinceStartup);
			}
		}

		public void OnGUI()
		{
			if (!CoopConfig.EnableOverlay.Value)
			{
				return;
			}
			bool flag = _guiCalls < 3;
			_guiCalls++;
			if (flag)
			{
				Log.Trace($"OnGUI {_guiCalls} begin");
			}
			long stamp = _performance.BeginMenu();
			try
			{
				if (_firstGui)
				{
					_firstGui = false;
					Log.Info("[Coop] first OnGUI");
				}
				bool menuWasVisible = MenuVisible || UI.ChatOpen;
				UI.Draw(flag);
				MenuFocus.AfterGui(menuWasVisible);
			}
			catch (Exception ex)
			{
				ReleaseMenuOnError();
				ReportError("OnGUI", ex);
			}
			finally
			{
				_performance.EndMenu(stamp);
			}
			if (flag)
			{
				Log.Trace($"OnGUI {_guiCalls} end");
			}
		}

		private void ReportError(string where, Exception ex)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			LastError = $"{where}: {ex.GetType().Name}: {ex.Message}";
			if (realtimeSinceStartup - _lastErrorAt > 5f)
			{
				_errorBurst = 0;
			}
			_lastErrorAt = realtimeSinceStartup;
			if (++_errorBurst <= 3)
			{
				Log.Error("[Coop] " + where, ex);
			}
		}

		private void HandleKeys()
		{
			//IL_002b: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			HandleMenuKey();
			HandleChatKey();
			if (!UI.ChatOpen)
			{
				TrySteamLaunchJoin();
				if (_keys.Pressed(CoopConfig.HostKey.Value))
				{
					HostSession();
				}
				if (_keys.Pressed(CoopConfig.JoinKey.Value))
				{
					JoinSession(CoopConfig.JoinAddress.Value);
				}
				if (_keys.Pressed(CoopConfig.LeaveKey.Value))
				{
					LeaveSession();
				}
				if (Life.IsSpectating && _keys.Pressed((KeyCode)290))
				{
					Life.CycleTarget();
				}
			}
		}

		private void HandleMenuKey()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (_keys.Pressed(CoopConfig.ToggleMenuKey.Value) && !UI.ChatOpen)
			{
				MenuVisible = !MenuVisible;
			}
		}

		private void HandleChatKey()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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)
			KeyCode value = CoopConfig.ChatKey.Value;
			bool num = _keys.Pressed(value);
			UI.TickChat(_keys.Held(value));
			if (num && !UI.ChatOpen && !MenuVisible)
			{
				UI.OpenChat();
			}
		}

		public void BeforeInputUpdate()
		{
			try
			{
				if (KeyEdge.GameHasFocus())
				{
					HandleMenuKey();
					HandleChatKey();
				}
				MenuFocus.Tick();
			}
			catch (Exception ex)
			{
				ReleaseMenuOnError();
				ReportError("Menu input", ex);
			}
		}

		private void ReleaseMenuOnError()
		{
			MenuVisible = false;
			try
			{
				UI.CloseChat(clearDraft: false);
			}
			catch
			{
			}
			try
			{
				MenuFocus.Release();
			}
			catch (Exception ex)
			{
				Log.Warn("[Menu input] restore: " + ex.Message);
			}
		}

		private void TrackLevel()
		{
			int currentLevelId = GameState.CurrentLevelId;
			bool isLoadingLevel = GameState.IsLoadingLevel;
			if (currentLevelId != _levelId)
			{
				Log.Info($"[Game] level changed {_levelId} -> {currentLevelId} ({GameState.CurrentSceneName})");
				HealthScaling.RestoreAll();
				_levelId = currentLevelId;
				MonsterClient.OnLevelChanged(currentLevelId);
				Authority.OnLevelChanged();
				MonsterHost.OnLevelChanged();
				MonsterIndex.Invalidate();
				HitRelay.ClearCaches();
			}
			if (isLoadingLevel != _loading)
			{
				_loading = isLoadingLevel;
				Log.Debug($"[Game] loading = {isLoadingLevel}");
			}
		}

		private void SendState(float now)
		{
			if (!Session.IsConnected)
			{
				return;
			}
			if (now >= _nextStateSend)
			{
				_nextStateSend = now + 1f / UnityMath.Max(1f, CoopConfig.PlayerSendRate.Value);
				PlayerFlags playerFlags = PlayerFlags.None;
				if (_loading || (Object)(object)Sampler.Player == (Object)null)
				{
					playerFlags |= PlayerFlags.Loading;
				}
				if (HitRelay.ClientSideHitsObserved)
				{
					playerFlags |= PlayerFlags.ClientSideHits;
				}
				if (Life.IsSpectating)
				{
					playerFlags |= PlayerFlags.Dead | PlayerFlags.Spectating;
				}
				PlayerStateMsg state = Sampler.Sample(_levelId, playerFlags);
				Session.SendPlayerState(state);
			}
			if (now >= _nextEquipCheck && (Object)(object)Sampler.Player != (Object)null)
			{
				_nextEquipCheck = now + 1f;
				PlayerEquipMsg playerEquipMsg = Sampler.SampleEquip(CoopConfig.EffectivePlayerName);
				if (!_equipSent || !playerEquipMsg.SameAs(in _lastEquip))
				{
					Session.SendPlayerEquip(playerEquipMsg);
					_lastEquip = playerEquipMsg;
					_equipSent = true;
					Log.Debug($"[Coop] sent equipment: weapon {playerEquipMsg.WeaponDefineId} head {playerEquipMsg.HeadId} body {playerEquipMsg.BodyId} acc {playerEquipMsg.AccessoriesId}");
				}
			}
		}

		private void AutoContinueTick(float now)
		{
			if (InstanceProfile.AutoContinue && !GameActive && !(now < _nextAutoContinue))
			{
				_nextAutoContinue = now + 2f;
				if (_autoContinueAttempts < 300)
				{
					_autoContinueAttempts++;
					PressThroughTitle(_autoContinueAttempts <= 3 || _autoContinueAttempts % 15 == 0);
				}
			}
		}

		public bool PressThroughTitle(bool log)
		{
			try
			{
				TitleView val = Il2CppUtil.FindObjectOfType<TitleView>();
				if ((Object)(object)val == (Object)null)
				{
					if (log)
					{
						Log.Debug("[Auto] title screen not ready yet");
					}
					return false;
				}
				try
				{
					InputManager instance = InputManager.Instance;
					if (instance != null)
					{
						instance.UISubmitInput((CallbackContext)null);
					}
				}
				catch (Exception ex)
				{
					if (log)
					{
						Log.Debug("[Auto] UISubmitInput: " + ex.Message);
					}
				}
				try
				{
					val.InvokeButton();
				}
				catch (Exception ex2)
				{
					if (log)
					{
						Log.Debug("[Auto] InvokeButton: " + ex2.Message);
					}
				}
				try
				{
					val.Continue();
				}
				catch (Exception ex3)
				{
					if (log)
					{
						Log.Debug("[Auto] Continue: " + ex3.Message);
					}
				}
				if (log)
				{
					Log.Info($"[Auto] title press + Continue() (attempt {_autoContinueAttempts})");
				}
				return true;
			}
			catch (Exception ex4)
			{
				if (log)
				{
					Log.Debug("[Auto] continue failed: " + ex4.Message);
				}
				return false;
			}
		}

		private void AutoStart(float now)
		{
			bool autoHost = InstanceProfile.AutoHost;
			bool flag = !string.IsNullOrEmpty(InstanceProfile.AutoJoin);
			if (_autoStarted)
			{
				if (flag && !Session.IsActive && Session.AllowAutoJoinRetry && _autoRetries < 30 && now >= _autoRetryAt)
				{
					_autoRetryAt = now + 5f;
					_autoRetries++;
					Log.Msg($"[Auto] retrying join {InstanceProfile.AutoJoin} ({_autoRetries})");
					JoinSession(InstanceProfile.AutoJoin);
				}
			}
			else if (!autoHost && !flag)
			{
				_autoStarted = true;
			}
			else if (_loading || _levelId < 0 || (Object)(object)GameState.LocalPlayer == (Object)null)
			{
				_autoStartAt = -1f;
			}
			else if (_autoStartAt < 0f)
			{
				_autoStartAt = now + 3f;
			}
			else if (!(now < _autoStartAt))
			{
				_autoStarted = true;
				if (autoHost)
				{
					Log.Msg("[Auto] hosting");
					HostSession();
				}
				else
				{
					Log.Msg("[Auto] joining " + InstanceProfile.AutoJoin);
					JoinSession(InstanceProfile.AutoJoin);
				}
			}
		}

		private void TrySteamLaunchJoin()
		{
			if (!_steamLaunchJoinChecked && !Session.IsActive && _levelId >= 0 && !_loading && !((Object)(object)GameState.LocalPlayer == (Object)null))
			{
				_steamLaunchJoinChecked = true;
				ulong num = SteamPresence.PendingLaunchJoin();
				if (num != 0L && num != SteamPresence.LocalSteamId)
				{
					Log.Msg($"[Steam] joining {num}, who invited us before the game started");
					UI.Notify("Joining your friend's session...");
					JoinSteamFriend(num);
				}
			}
		}

		private INetTransport CreateTransport()
		{
			if (CoopConfig.Transport.Value == TransportKind.Steam)
			{
				if (SteamP2PTransport.IsAvailable)
				{
					return new SteamP2PTransport();
				}
				Log.Warn("[Coop] Steam is not initialised; falling back to UDP.");
				UI.Notify("Steam unavailable, using UDP");
			}
			return new UdpTransport();
		}

		public void HostSession()
		{
			LogPrivacy.RegisterName(SteamPresence.LocalName);
			Session.LocalName = CoopConfig.EffectivePlayerName;
			Session.LocalSteamId = SteamP2PTransport.LocalSteamIdOrZero;
			Session.MaxPlayers = CoopConfig.MaxPlayers.Value;
			Session.ConfiguredEnemyHpPerExtraPlayer = CoopConfig.EnemyHpPerExtraPlayer.Value;
			INetTransport netTransport = CreateTransport();
			if (!Session.Host(netTransport, CoopConfig.EffectivePort))
			{
				UI.Notify("Could not start hosting: " + Session.StatusText);
				netTransport.Dispose();
			}
			else if (CoopConfig.Transport.Value == TransportKind.Steam)
			{
				SteamPresence.Advertise();
			}
		}

		public void JoinSteamFriend(ulong hostSteamId)
		{
			if (hostSteamId != 0L)
			{
				if (CoopConfig.Transport.Value != TransportKind.Steam)
				{
					CoopConfig.Transport.Value = TransportKind.Steam;
					Log.Info("[Coop] switched to the Steam transport to join a friend");
				}
				JoinSession(hostSteamId.ToString());
			}
		}

		public void InviteOverSteam()
		{
			if (!Session.IsHost)
			{
				UI.Notify("Host a session first");
				return;
			}
			if (!SteamPresence.IsAvailable)
			{
				UI.Notify("Steam is not available");
				return;
			}
			SteamPresence.Advertise();
			if (SteamPresence.OpenInviteOverlay())
			{
				UI.Notify("Steam invite dialog opened");
			}
			else
			{
				UI.Notify("Could not open the Steam overlay");
			}
		}

		public void JoinSession(string address)
		{
			LogPrivacy.RegisterName(SteamPresence.LocalName);
			Session.LocalName = CoopConfig.EffectivePlayerName;
			Session.LocalSteamId = SteamP2PTransport.LocalSteamIdOrZero;
			INetTransport netTransport = CreateTransport();
			if (!Session.Join(netTransport, address, CoopConfig.EffectivePort))
			{
				UI.Notify("Could not connect: " + Session.StatusText);
				netTransport.Dispose();
			}
		}

		public void LeaveSession()
		{
			SteamPresence.StopAdvertising();
			_autoStarted = true;
			_autoRetries = int.MaxValue;
			if (Session.IsActive)
			{
				Session.Leave();
			}
			else
			{
				UI.Notify("Not in a session");
			}
		}

		public void BeforeMonsterReset()
		{
			Threat.Clear();
			MonsterClient.ReleaseAll();
			HealthScaling.RestoreAll();
			MonsterIndex.Invalidate();
			HitRelay.ClearCaches();
			MonsterHost.OnLevelChanged();
		}

		public void OnRemoteRest(int levelId)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!Session.IsHost || !Session.IsConnected)
			{
				return;
			}
			if (GameState.CurrentLevelId == levelId && GameActive && !Loading)
			{
				LevelRoot currentLevelRoot = GameState.CurrentLevelRoot;
				if (currentLevelRoot != null)
				{
					currentLevelRoot.ResetMonster();
				}
				OnLocalSceneReset(isDead: false);
			}
			else
			{
				Session.SendSceneReset(new SceneResetMsg
				{
					LevelId = levelId,
					IsDead = false
				});
			}
		}

		public void OnLocalSceneReset(bool isDead)
		{
			Threat.Clear();
			MonsterIndex.Invalidate();
			HitRelay.ClearCaches();
			MonsterHost.OnLevelChanged();
			if (Session.IsHost && Session.IsConnected)
			{
				MonsterClient.ReleaseAll();
				Authority.Clear();
				Log.Msg("[Game] telling clients to reset their monsters (host " + (isDead ? "died" : "rested") + ")");
				Session.SendSceneReset(new SceneResetMsg
				{
					LevelId = _levelId,
					IsDead = isDead
				});
			}
		}

		public void OnGameLoadNewScene()
		{
			World.Clear();
			HealthScaling.RestoreAll();
			Log.Info("[Game] ProcedureManager.OnLoadNewScene");
			MonsterIndex.Invalidate();
			HitRelay.ClearCaches();
		}

		public void OnGameStart()
		{
			Log.Info("[Game] ProcedureManager.StartGameInitAllLogic -> game active");
			GameActive = true;
			_levelId = -1;
		}

		public void OnGameClose()
		{
			World.Clear();
			HealthScaling.RestoreAll();
			Log.Info("[Game] ProcedureManager.CloseAllLogic -> game inactive");
			GameActive = false;
			Life.OnGameClose();
			Threat.Clear();
			Rewards.OnGameClose();
			_levelId = -1;
			_loading = true;
			MonsterIndex.Invalidate();
			HitRelay.ClearCaches();
			MonsterHost.OnLevelChanged();
			MonsterClient.ReleaseAll();
			Authority.Clear();
			Ghosts.DespawnAll();
			Sampler.Bind(null);
			if (_fakeGhost != null)
			{
				ToggleFakeGhost();
			}
		}

		public void RunEachFrame(float seconds, Action action)
		{
			_frameAction = action;
			_frameActionUntil = Time.realtimeSinceStartup + seconds;
		}

		public void RunAfter(float seconds, Action action)
		{
			_delayedAction = action;
			_delayedAt = Time.realtimeSinceStartup + seconds;
		}

		private void PumpFrameAction(float now)
		{
			if (_delayedAction != null && now >= _delayedAt)
			{
				Action delayedAction = _delayedAction;
				_delayedAction = null;
				try
				{
					delayedAction();
				}
				catch (Exception ex)
				{
					Log.Warn("[Dev] delayed action: " + ex.Message);
				}
			}
			if (_frameAction == null)
			{
				return;
			}
			if (now > _frameActionUntil)
			{
				_frameAction = null;
				return;
			}
			try
			{
				_frameAction();
			}
			catch (Exception ex2)
			{
				Log.Warn("[Dev] frame action: " + ex2.Message);
				_frameAction = null;
			}
		}

		public void ToggleFakeGhost()
		{
			if (_fakeGhost != null)
			{
				try
				{
					_fakeGhost.Despawn();
				}
				catch (Exception ex)
				{
					Log.Error("[Fake] despawn", ex);
				}
				_fakeGhost = null;
				_fakePeer = null;
				Log.Msg("[Fake] fake ghost removed");
			}
			else
			{
				_fakePeer = new Peer
				{
					Id = 250,
					Name = "FakeGhost",
					HandshakeDone = true
				};
				_fakeGhost = new RemotePlayer(_fakePeer);
				Log.Msg("[Fake] fake ghost enabled (mirrors the local player 2m to the side)");
			}
		}

		private void UpdateFakeGhost(float now)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			if (_fakeGhost == null)
			{
				return;
			}
			Player localPlayer = GameState.LocalPlayer;
			Sampler.Bind(localPlayer);
			if ((Object)(object)localPlayer != (Object)null && now >= _nextFakeSend)
			{
				_nextFakeSend = now + 0.05f;
				PlayerStateMsg o = Sampler.Sample(_levelId, PlayerFlags.None);
				_fakeState.CopyFrom(o);
				Transform val = GameState.SafeRoot(localPlayer);
				Vector3 val2 = (((Object)(object)val != (Object)null) ? val.right : Vector3.right);
				_fakeState.X += val2.x * 2f;
				_fakeState.Z += val2.z * 2f;
				_fakeState.PeerId = 250;
				_fakeGhost.OnState(_fakeState, now);
				if (!_fakeGhost.IsSpawned && (Object)(object)Sampler.Player != (Object)null)
				{
					_fakeGhost.OnEquip(Sampler.SampleEquip("FakeGhost"));
				}
			}
			_fakeGhost.Update(now, _levelId, _loading, Ghosts.HolderTransform);
		}
	}
	public sealed class MonsterIndex
	{
		private readonly Dictionary<int, Monster> _map = new Dictionary<int, Monster>();

		private float _builtAt = float.NegativeInfinity;

		private int _levelId = -1;

		private IntPtr _root;

		private const float RefreshSeconds = 2f;

		private const float MissingRetrySeconds = 0.5f;

		public int Count => _map.Count;

		public long RebuildCount { get; private set; }

		public long MissCount { get; private set; }

		public void Invalidate()
		{
			_map.Clear();
			_builtAt = float.NegativeInfinity;
		}

		public Monster Find(int instanceId)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			int currentLevelId = GameState.CurrentLevelId;
			LevelRoot currentLevelRoot = GameState.CurrentLevelRoot;
			IntPtr intPtr = ((currentLevelRoot != null) ? ((Il2CppObjectBase)currentLevelRoot).Pointer : IntPtr.Zero);
			if (currentLevelId != _levelId || intPtr != _root)
			{
				Invalidate();
				_levelId = currentLevelId;
				_root = intPtr;
			}
			Monster value;
			bool flag = _map.TryGetValue(instanceId, out value) && Il2CppUtil.Alive((Object)(object)value);
			float num = realtimeSinceStartup - _builtAt;
			if (num < 0f || num >= (flag ? 2f : 0.5f))
			{
				_builtAt = realtimeSinceStartup;
				RebuildCount++;
				_map.Clear();
				foreach (Monster item in GameState.CollectMonsters(currentLevelRoot))
				{
					if (Il2CppUtil.Alive((Object)(object)item))
					{
						int num2 = GameState.MonsterInstanceId(item);
						if (num2 >= 0)
						{
							_map[num2] = item;
						}
					}
				}
				flag = _map.TryGetValue(instanceId, out value) && Il2CppUtil.Alive((Object)(object)value);
			}
			if (!flag)
			{
				MissCount++;
			}
			if (!flag)
			{
				return null;
			}
			return value;
		}
	}
	public static class InstanceProfile
	{
		public static string Name = "";

		public static string PlayerName;

		public static bool ReadOnlySaves;

		public static int Port = -1;

		public static bool AutoContinue;

		public static bool AutoHost;

		public static string AutoJoin;

		public static string FileSuffix
		{
			get
			{
				if (!string.IsNullOrEmpty(Name))
				{
					return "." + Name;
				}
				return "";
			}
		}

		public static bool IsSecondary => !string.IsNullOrEmpty(Name);

		public static void Init()
		{
			Name = Clean(Get("AILIMITCOOP_PROFILE"));
			PlayerName = Get("AILIMITCOOP_NAME");
			ReadOnlySaves = Flag("AILIMITCOOP_READONLY_SAVE");
			AutoContinue = Flag("AILIMITCOOP_AUTOCONTINUE");
			AutoHost = Flag("AILIMITCOOP_AUTOHOST");
			AutoJoin = Get("AILIMITCOOP_AUTOJOIN");
			string text = Get("AILIMITCOOP_PORT");
			if (!string.IsNullOrEmpty(text) && int.TryParse(text, out var result))
			{
				Port = result;
			}
		}

		public static string Describe()
		{
			if (IsSecondary || ReadOnlySaves || AutoContinue || AutoHost || !string.IsNullOrEmpty(AutoJoin))
			{
				return $"profile='{Name}' name='{PlayerName}' readOnlySaves={ReadOnlySaves} autoContinue={AutoContinue} autoHost={AutoHost} autoJoin='{AutoJoin}' port={((Port > 0) ? Port.ToString() : "config")}";
			}
			return "";
		}

		private static string Get(string key)
		{
			try
			{
				return Environment.GetEnvironmentVariable(key)?.Trim();
			}
			catch
			{
				return null;
			}
		}

		private static bool Flag(string key)
		{
			string text = Get(key);
			if (!string.IsNullOrEmpty(text) && text != "0")
			{
				return !text.Equals("false", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private static string Clean(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "";
			}
			char[] array = s.ToCharArray();
			for (int i = 0; i < array.Length; i++)
			{
				if (!char.IsLetterOrDigit(array[i]) && array[i] != '_' && array[i] != '-')
				{
					array[i] = '_';
				}
			}
			return new string(array);
		}
	}
	[BepInPlugin("com.ailimit.coop", "AI LIMIT Co-op", "0.2.4")]
	public class Plugin : BasePlugin
	{
		public const string Guid = "com.ailimit.coop";

		public const string Name = "AI LIMIT Co-op";

		public const string Version = "0.2.4";

		private static WillRenderCanvases _frameAction;

		private static Action _beforeInput;

		public override void Load()
		{
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			InstanceProfile.Init();
			Log.Init(((BasePlugin)this).Log, Path.Combine(Paths.BepInExRootPath, "coop_trace" + InstanceProfile.FileSuffix + ".txt"));
			ManagedExceptionCounter.Install();
			((BasePlugin)this).Config.SaveOnConfigSet = false;
			CoopConfig.Bind(((BasePlugin)this).Config);
			((BasePlugin)this).Config.SaveOnConfigSet = !InstanceProfile.IsSecondary;
			if (((BasePlugin)this).Config.SaveOnConfigSet)
			{
				try
				{
					((BasePlugin)this).Config.Save();
				}
				catch (IOException ex)
				{
					Log.Warn("Config is busy; using loaded settings: " + ex.Message);
				}
			}
			Log.Verbose = CoopConfig.Verbose.Value;
			CoopConfig.Verbose.SettingChanged += delegate
			{
				Log.Verbose = CoopConfig.Verbose.Value;
			};
			Log.Msg($"{"AI LIMIT Co-op"} v{"0.2.4"} loading (transport {CoopConfig.Transport.Value}, port {CoopConfig.EffectivePort})");
			Log.Info($"[Net] Protocol {5}, monster message budget {1100} bytes; send acceptance is local only.");
			Log.Info("[Party life] Death spectating enabled; rest or boss rewards revive, party wipe resumes native respawn.");
			Log.Info("[MonsterSync] Proximity simulation ownership with combat locks and independent multiplayer threat.");
			string text = InstanceProfile.Describe();
			if (text.Length > 0)
			{
				Log.Msg("Instance profile: " + text);
			}
			Log.Trace("config bound");
			if (CoopConfig.ForceRunInBackground.Value || InstanceProfile.IsSecondary)
			{
				try
				{
					Application.runInBackground = true;
					Log.Trace("runInBackground forced");
				}
				catch (Exception ex2)
				{
					Log.Warn("Could not set runInBackground: " + ex2.Message);
				}
			}
			CoopRuntime.Create();
			Log.Trace("runtime created");
			try
			{
				Hooks.Apply();
				Log.Trace("hooks applied");
			}
			catch (Exception ex3)
			{
				Log.Error("Failed to apply Harmony patches", ex3);
			}
			RegisterFrameDriver();
			RegisterEarlyInput();
			Log.Msg($"{"AI LIMIT Co-op"} loaded. Keys: {CoopConfig.ToggleMenuKey.Value} menu, {CoopConfig.HostKey.Value} host, {CoopConfig.JoinKey.Value} join, {CoopConfig.LeaveKey.Value} leave.");
		}

		private static void RegisterEarlyInput()
		{
			try
			{
				_beforeInput = DelegateSupport.ConvertDelegate<Action>((Delegate)(Action)delegate
				{
					CoopRuntime.Instance?.BeforeInputUpdate();
				});
				InputSystem.onBeforeUpdate += _beforeInput;
				MenuInputFocus.EarlyInputRegistered = true;
				Log.Info("[Menu input] " + MenuInputFocus.Readiness);
			}
			catch (Exception ex)
			{
				Log.Error("Could not register menu input capture", ex);
			}
		}

		private static void RegisterFrameDriver()
		{
			try
			{
				_frameAction = DelegateSupport.ConvertDelegate<WillRenderCanvases>((Delegate)new Action(Hooks.FrameHooks.Tick));
				Canvas.willRenderCanvases += _frameAction;
				Log.Trace("frame driver registered (Canvas.willRenderCanvases)");
			}
			catch (Exception ex)
			{
				Log.Error("Failed to register the per-frame callback; the mod cannot run", ex);
			}
		}
	}
}
namespace AILimitCoop.Util
{
	internal enum CoopWork
	{
		Input,
		Network,
		Life,
		LocalState,
		Ghosts,
		MonsterSend,
		MonsterReceive,
		Threat,
		Rewards,
		Other,
		Menu,
		FrameGap,
		Count
	}
	internal sealed class FrameTimingWindow
	{
		private readonly double[] _sum = new double[12];

		private readonly double[] _max = new double[12];

		private readonly int[] _count = new int[12];

		public int Count(CoopWork stage)
		{
			return _count[(int)stage];
		}

		public double Mean(CoopWork stage)
		{
			if (Count(stage) != 0)
			{
				return _sum[(int)stage] / (double)Count(stage);
			}
			return 0.0;
		}

		public double Max(CoopWork stage)
		{
			return _max[(int)stage];
		}

		public void Record(CoopWork stage, double milliseconds)
		{
			if (double.IsFinite(milliseconds) && !(milliseconds < 0.0) && stage >= CoopWork.Input && stage < CoopWork.Count)
			{
				_count[(int)stage]++;
				_sum[(int)stage] += milliseconds;
				_max[(int)stage] = Math.Max(_max[(int)stage], milliseconds);
			}
		}

		public void Clear()
		{
			Array.Clear(_sum, 0, _sum.Length);
			Array.Clear(_max, 0, _max.Length);
			Array.Clear(_count, 0, _count.Length);
		}

		public string Describe()
		{
			StringBuilder stringBuilder = new StringBuilder("stage ms mean/max (calls):");
			for (int i = 0; i < _count.Length; i++)
			{
				if (_count[i] != 0)
				{
					stringBuilder.Append(' ').Append((CoopWork)i).Append('=')
						.Append(Mean((CoopWork)i).ToString("F2", CultureInfo.InvariantCulture))
						.Append('/')
						.Append(_max[i].ToString("F2", CultureInfo.InvariantCulture))
						.Append('(')
						.Append(_count[i])
						.Append(')');
				}
			}
			return stringBuilder.ToString();
		}
	}
	public static class Il2CppUtil
	{
		public static Object StringKey(string s)
		{
			return (Object)(object)String.op_Implicit(s);
		}

		public static bool Alive(Object o)
		{
			try
			{
				if (o == null || ((Il2CppObjectBase)o).Pointer == IntPtr.Zero)
				{
					return false;
				}
				return o.m_CachedPtr != IntPtr.Zero || o != (Object)null;
			}
			catch
			{
				return false;
			}
		}

		public static Vector3 MakeVec3(float x, float y, float z)
		{
			//IL_0002: 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)
			return new Vector3
			{
				x = x,
				y = y,
				z = z
			};
		}

		public static Rect MakeRect(float x, float y, float width, float height)
		{
			//IL_0002: 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)
			return new Rect
			{
				m_XMin = x,
				m_YMin = y,
				m_Width = width,
				m_Height = height
			};
		}

		public static Color MakeColor(float r, float g, float b, float a)
		{
			//IL_0002: 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)
			return new Color
			{
				r = r,
				g = g,
				b = b,
				a = a
			};
		}

		public static Quaternion Yaw(float degrees)
		{
			//IL_000f: 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)
			double num = (double)degrees * (Math.PI / 360.0);
			return new Quaternion
			{
				y = (float)Math.Sin(num),
				w = (float)Math.Cos(num)
			};
		}

		public static float SqrDistance(Vector3 a, Vector3 b)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			float num = a.x - b.x;
			float num2 = a.y - b.y;
			float num3 = a.z - b.z;
			return num * num + num2 * num2 + num3 * num3;
		}

		public static T FindObjectOfType<T>() where T : Object
		{
			try
			{
				Object val = Object.FindObjectOfType(Il2CppType.Of<T>());
				return (val == (Object)null) ? default(T) : ((Il2CppObjectBase)val).TryCast<T>();
			}
			catch (Exception ex)
			{
				Log.Debug("FindObjectOfType<" + typeof(T).Name + "> failed: " + ex.Message);
				return default(T);
			}
		}

		public static IEnumerable<T> Each<T>(List<T> list)
		{
			if (list == null)
			{
				yield break;
			}
			int count;
			try
			{
				count = list.Count;
			}
			catch
			{
				yield break;
			}
			for (int i = 0; i < count; i++)
			{
				T val;
				try
				{
					val = list[i];
				}
				catch
				{
					break;
				}
				yield return val;
			}
		}

		public static IEnumerable<T> Each<T>(Il2CppArrayBase<T> array)
		{
			if (array != null)
			{
				int count = array.Length;
				for (int i = 0; i < count; i++)
				{
					yield return array[i];
				}
			}
		}

		public static Il2CppStructArray<byte> ToIl2CppBytes(byte[] data, int length)
		{
			Il2CppStructArray<byte> val = new Il2CppStructArray<byte>((long)length);
			for (int i = 0; i < length; i++)
			{
				((Il2CppArrayBase<byte>)(object)val)[i] = data[i];
			}
			return val;
		}

		public static int StableHash(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return 0;
			}
			uint num = 2166136261u;
			foreach (char c in s)
			{
				num ^= c;
				num *= 16777619;
			}
			return (int)num;
		}

		public static string DescribeHierarchy(GameObject root, int maxDepth = 2, int maxChildren = 40)
		{
			StringBuilder stringBuilder = new StringBuilder();
			Describe(root.transform, 0, maxDepth, maxChildren, stringBuilder);
			return stringBuilder.ToString();
		}

		private static void Describe(Transform t, int depth, int maxDepth, int maxChildren, StringBuilder sb)
		{
			sb.Append(' ', depth * 2).Append(((Object)t).name).Append(((Component)t).gameObject.activeSelf ? "" : " (inactive)");
			try
			{
				Il2CppArrayBase<Component> components = ((Component)t).GetComponents<Component>();
				List<string> list = new List<string>();
				foreach (Component item in Each<Component>(components))
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					string text = ((MemberInfo)((Object)item).GetIl2CppType()).Name;
					if (!(text == "Transform"))
					{
						Behaviour val = ((Il2CppObjectBase)item).TryCast<Behaviour>();
						if ((Object)(object)val != (Object)null && !val.enabled)
						{
							text += "(off)";
						}
						list.Add(text);
					}
				}
				if (list.Count > 0)
				{
					sb.Append("  [").Append(string.Join(", ", list)).Append(']');
				}
			}
			catch (Exception ex)
			{
				sb.Append("  <components failed: ").Append(ex.Message).Append('>');
			}
			sb.AppendLine();
			if (depth < maxDepth)
			{
				int childCount = t.childCount;
				for (int i = 0; i < childCount && i < maxChildren; i++)
				{
					Describe(t.GetChild(i), depth + 1, maxDepth, maxChildren, sb);
				}
				if (childCount > maxChildren)
				{
					sb.Append(' ', (depth + 1) * 2).Append("... ").Append(childCount - maxChildren)
						.AppendLine(" more");
				}
			}
		}

		public static string Vec(Vector3 v)
		{
			//IL_0017: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			return $"({v.x:F2}, {v.y:F2}, {v.z:F2})";
		}
	}
	public static class Log
	{
		private static ManualLogSource _source;

		public static bool Verbose;

		private static string _tracePath;

		public static void Init(ManualLogSource source, string tracePath = null)
		{
			_source = source;
			_tracePath = tracePath;
			if (_tracePath != null)
			{
				try
				{
					File.WriteAllText(_tracePath, $"{DateTime.Now:HH:mm:ss.fff} trace start\n");
				}
				catch
				{
					_tracePath = null;
				}
			}
		}

		public static void Trace(string msg)
		{
			if (_tracePath == null)
			{
				return;
			}
			try
			{
				File.AppendAllText(_tracePath, $"{DateTime.Now:HH:mm:ss.fff} {LogPrivacy.Redact(msg)}\n");
			}
			catch
			{
			}
		}

		public static void Info(string msg)
		{
			ManualLogSource source = _source;
			if (source != null)
			{
				source.LogInfo((object)LogPrivacy.Redact(msg));
			}
		}

		public static void Msg(string msg)
		{
			ManualLogSource source = _source;
			if (source != null)
			{
				source.LogMessage((object)LogPrivacy.Redact(msg));
			}
		}

		public static void Warn(string msg)
		{
			ManualLogSource source = _source;
			if (source != null)
			{
				source.LogWarning((object)LogPrivacy.Redact(msg));
			}
		}

		public static void Error(string msg)
		{
			ManualLogSource source = _source;
			if (source != null)
			{
				source.LogError((object)LogPrivacy.Redact(msg));
			}
		}

		public static void Error(string context, Exception ex)
		{
			ManualLogSource source = _source;
			if (source != null)
			{
				source.LogError((object)LogPrivacy.Redact($"{context}: {ex.GetType().Name}: {ex.Message}\n{ex.StackTrace}"));
			}
		}

		public static void Debug(string msg)
		{
			if (Verbose)
			{
				ManualLogSource source = _source;
				if (source != null)
				{
					source.LogInfo((object)("[dbg] " + LogPrivacy.Redact(msg)));
				}
			}
		}
	}
	public static class LogPrivacy
	{
		private const int MaxLabelsPerKind = 256;

		private const int MaxNameLength = 256;

		private const RegexOptions Options = RegexOptions.Compiled | RegexOptions.CultureInvariant;

		private static readonly Regex SteamIds;

		private static readonly Regex Ipv4;

		private static readonly Regex Ipv6;

		private static readonly Regex AccountFolder;

		private static readonly Regex Placeholder;

		private static readonly HashSet<string> LogWords;

		private static readonly object Gate;

		private static readonly Dictionary<string, string> SteamLabels;

		private static readonly Dictionary<string, string> IpLabels;

		private static readonly Dictionary<string, string> NameLabels;

		private static Regex _names;

		private static Regex _userName;

		private static Regex _machineName;

		static LogPrivacy()
		{
			SteamIds = new Regex("(?<!\\d)7656119\\d{10}(?!\\d)", RegexOptions.Compiled | RegexOptions.CultureInvariant);
			Ipv4 = new Regex("(?<![\\w.])(?<!Version=)(?:\\d{1,3}\\.){3}\\d{1,3}(?!\\w|\\.\\d)", RegexOptions.Compiled | RegexOptions.CultureInvariant);
			Ipv6 = new Regex("(?<![\\w:.])(?:[0-9A-Fa-f]{0,4}:){2,7}[0-9A-Fa-f]{0,4}(?![\\w:])", RegexOptions.Compiled | RegexOptions.CultureInvariant);
			AccountFolder = new Regex("((?:[A-Za-z]:[\\\\/]+Users|(?:^|[\\\\/])home)[\\\\/]+)(?:[^\\\\/\\r\\n\"'<>|:*?]{1,64}?(?=[\\\\/])|[^\\s\\\\/\"'<>|:*?;,()\\[\\]]+)", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.CultureInvariant);
			Placeholder = new Regex("^(?:Player\\d*|steam-user-\\d+|ip-\\d+|name-\\d+)$", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.CultureInvariant);
			LogWords = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
			{
				"host", "client", "peer", "player", "ghost", "session", "steam", "udp", "user", "name",
				"level", "monster", "monstersync", "boss", "game", "coop", "party", "life", "menu", "input",
				"chat", "local", "unknown", "test", "hit", "threat", "rewards", "overlay", "hooks", "interaction",
				"perf", "net", "send", "types", "auto", "fake", "dev", "dbg", "trace", "moderation",
				"combat", "safety", "joined", "left", "username", "computername"
			};
			Gate = new object();
			SteamLabels = new Dictionary<string, string>(StringComparer.Ordinal);
			IpLabels = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			NameLabels = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			string userName = null;
			string machineName = null;
			try
			{
				userName = Environment.UserName;
			}
			catch
			{
			}
			try
			{
				machineName = Environment.MachineName;
			}
			catch
			{
			}
			UseEnvironment(userName, machineName);
		}

		public static void UseEnvironment(string userName, string machineName)
		{
			_userName = (IsHideable(userName) ? WholeWords(new string[1] { userName.Trim() }) : null);
			_machineName = (IsHideable(machineName) ? WholeWords(new string[1] { machineName.Trim() }) : null);
		}

		public static void RegisterName(string name)
		{
			if (!IsHideable(name))
			{
				return;
			}
			name = name.Trim();
			lock (Gate)
			{
				if (!NameLabels.ContainsKey(name) && NameLabels.Count < 256)
				{
					NameLabels[name] = "name-" + (NameLabels.Count + 1);
					_names = WholeWords(NameLabels.Keys);
				}
			}
		}

		public static void Reset()
		{
			lock (Gate)
			{
				SteamLabels.Clear();
				IpLabels.Clear();
				NameLabels.Clear();
				_names = null;
			}
		}

		public static string Redact(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			text = AccountFolder.Replace(text, "$1%USERNAME%");
			text = SteamIds.Replace(text, (Match m) => Label(SteamLabels, m.Value, "steam-user"));
			text = Ipv4.Replace(text, (Match m) => (!IsHiddenIpv4(m.Value)) ? m.Value : Label(IpLabels, m.Value, "ip"));
			text = Ipv6.Replace(text, (Match m) => (!LooksLikeIpv6(m.Value)) ? m.Value : Label(IpLabels, m.Value, "ip"));
			Regex names = _names;
			Regex userName = _userName;
			Regex machineName = _machineName;
			if (names != null)
			{
				text = names.Replace(text, delegate(Match m)
				{
					lock (Gate)
					{
						string value;
						return NameLabels.TryGetValue(m.Value, out value) ? value : "name";
					}
				});
			}
			if (machineName != null)
			{
				text = machineName.Replace(text, "%COMPUTERNAME%");
			}
			if (userName != null)
			{
				text = userName.Replace(text, "%USERNAME%");
			}
			return text;
		}

		private static string Label(Dictionary<string, string> labels, string value, string kind)
		{
			lock (Gate)
			{
				if (labels.TryGetValue(value, out var value2))
				{
					return value2;
				}
				if (labels.Count >= 256)
				{
					return kind;
				}
				return labels[value] = kind + "-" + (labels.Count + 1);
			}
		}

		private static bool IsHiddenIpv4(string text)
		{
			string[] array = text.Split('.');
			int[] array2 = new int[4];
			for (int i = 0; i < 4; i++)
			{
				if (!int.TryParse(array[i], out array2[i]) || array2[i] > 255)
				{
					return false;
				}
			}
			if (array2[0] != 127)
			{
				return (array2[0] | array2[1] | array2[2] | array2[3]) != 0;
			}
			return false;
		}

		private static bool LooksLikeIpv6(string text)
		{
			if (text == "::" || text == "::1" || !text.Any(Uri.IsHexDigit))
			{
				return false;
			}
			if (!text.Contains("::"))
			{
				return text.Count((char c) => c == ':') >= 5;
			}
			return true;
		}

		private static bool IsHideable(string word)
		{
			word = word?.Trim();
			if (!string.IsNullOrEmpty(word) && word.Length >= 3 && word.Length <= 256 && word.Any(char.IsLetter) && !LogWords.Contains(word))
			{
				return !Placeholder.IsMatch(word);
			}
			return false;
		}

		private static Regex WholeWords(IEnumerable<string> words)
		{
			return new Regex("(?<![\\p{L}\\p{N}_])(?:" + string.Join("|", words.OrderByDescending((string w) => w.Length).Select(Regex.Escape)) + ")(?![\\p{L}\\p{N}_])", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
		}
	}
	internal static class ManagedExceptionCounter
	{
		private static long _count;

		private static int _installed;

		public static long Count => Interlocked.Read(in _count);

		public static void Install()
		{
			if (Interlocked.Exchange(ref _installed, 1) == 0)
			{
				AppDomain.CurrentDomain.FirstChanceException += delegate
				{
					Interlocked.Increment(ref _count);
				};
			}
		}
	}
	internal sealed class SessionPerformance
	{
		private readonly FrameTimingWindow _window = new FrameTimingWindow();

		private readonly int[] _gc = new int[3];

		private bool _active;

		private long _stamp;

		private long _lastFrame;

		private long _allocated;

		private long _scans;

		private long _misses;

		private long _scanFaults;

		private long _executeSkips;

		private long _exceptions;

		private float _windowStart;

		private static double Milliseconds(long ticks)
		{
			return (double)ticks * (1000.0 / (double)Stopwatch.Frequency);
		}

		public void Begin(CoopRuntime rt, float now)
		{
			bool flag = rt.GameActive && rt.Session.IsConnected;
			if (flag != _active)
			{
				_active = flag;
				_window.Clear();
				_lastFrame = 0L;
				ResetBaseline(rt, now);
			}
			if (_active)
			{
				_stamp = Stopwatch.GetTimestamp();
				if (_lastFrame != 0L)
				{
					_window.Record(CoopWork.FrameGap, Milliseconds(_stamp - _lastFrame));
				}
				_lastFrame = _stamp;
			}
		}

		public void Mark(CoopWork stage)
		{
			if (_active)
			{
				long timestamp = Stopwatch.GetTimestamp();
				_window.Record(stage, Milliseconds(timestamp - _stamp));
				_stamp = timestamp;
			}
		}

		public long BeginMenu()
		{
			if (!_active)
			{
				return 0L;
			}
			return Stopwatch.GetTimestamp();
		}

		public void EndMenu(long stamp)
		{
			if (stamp != 0L && _active)
			{
				_window.Record(CoopWork.Menu, Milliseconds(Stopwatch.GetTimestamp() - stamp));
			}
		}

		private void ResetBaseline(CoopRuntime rt, float now)
		{
			_windowStart = now;
			_allocated = GC.GetAllocatedBytesForCurrentThread();
			for (int i = 0; i < _gc.Length; i++)
			{
				_gc[i] = GC.CollectionCount(i);
			}
			_scans = rt.MonsterIndex.RebuildCount;
			_misses = rt.MonsterIndex.MissCount;
			_scanFaults = Hooks.ExecuteScanFaults;
			_executeSkips = Hooks.GhostExecuteSkips;
			_exceptions = ManagedExceptionCounter.Count;
		}

		public void End(CoopRuntime rt, float now)
		{
			if (!_active)
			{
				return;
			}
			Mark(CoopWork.Other);
			if (now - _windowStart < 30f)
			{
				return;
			}
			try
			{
				double num = now - _windowStart;
				double value = (double)Math.Max(0L, GC.GetAllocatedBytesForCurrentThread() - _allocated) / 1048576.0 / num;
				string value2 = "unavailable";
				try
				{
					using Process process = Process.GetCurrentProcess();
					value2 = ((double)process.WorkingSet64 / 1048576.0).ToString("F0", CultureInfo.InvariantCulture);
				}
				catch
				{
				}
				Log.Info($"[Perf] windowSec={num:F1} level={rt.LevelId} loading={rt.Loading} menu={rt.MenuVisible} managedMiB={(double)GC.GetTotalMemory(forceFullCollection: false) / 1048576.0:F1} residentMiB={value2} mainThreadManagedAllocMiBps={value:F2} gc0/1/2={GC.CollectionCount(0) - _gc[0]}/{GC.CollectionCount(1) - _gc[1]}/{GC.CollectionCount(2) - _gc[2]} ghosts={rt.Ghosts.Count} retiredGhostPointers={GhostRegistry.ZombieCount} ghostExecuteSkips={Hooks.GhostExecuteSkips - _executeSkips} executeScanFaults={Hooks.ExecuteScanFaults - _scanFaults} managedExceptions={ManagedExceptionCounter.Count - _exceptions} replicas={rt.MonsterClient.ControlledCount} indexActors={rt.MonsterIndex.Count} indexScans={rt.MonsterIndex.RebuildCount - _scans} missingLookups={rt.MonsterIndex.MissCount - _misses} safetyTotalsLateMachines/Enemy/Camera={GhostMachineSafety.LateMachines}/{NativeCombatSafety.InvalidEnemyUpdates}/{NativeCombatSafety.InvalidCameraTargets}");
				Log.Info("[Perf] " + _window.Describe());
			}
			catch (Exception ex)
			{
				Log.Debug("[Perf] summary unavailable: " + ex.Message);
			}
			finally
			{
				_window.Clear();
				ResetBaseline(rt, now);
			}
		}
	}
	public static class UnityMath
	{
		public static float Max(float a, float b)
		{
			if (!(a > b))
			{
				return b;
			}
			return a;
		}

		public static float Min(float a, float b)
		{
			if (!(a < b))
			{
				return b;
			}
			return a;
		}

		public static float Abs(float value)
		{
			return Math.Abs(value);
		}

		public static float Sqrt(float value)
		{
			return (float)Math.Sqrt(value);
		}

		public static float Floor(float value)
		{
			return (float)Math.Floor(value);
		}

		public static float Exp(float power)
		{
			return (float)Math.Exp(power);
		}

		public static float Clamp(float value, float min, float max)
		{
			if (value < min)
			{
				value = min;
			}
			else if (value > max)
			{
				value = max;
			}
			return value;
		}

		public static float Clamp01(float value)
		{
			if (!(value < 0f))
			{
				if (!(value > 1f))
				{
					return value;
				}
				return 1f;
			}
			return 0f;
		}

		public static float Lerp(float a, float b, float t)
		{
			return a + (b - a) * Clamp01(t);
		}

		public static float MoveTowards(float current, float target, float maxDelta)
		{
			if (!(Math.Abs(target - current) <= maxDelta))
			{
				return current + ((target - current >= 0f) ? 1f : (-1f)) * maxDelta;
			}
			return target;
		}

		public static float Repeat(float t, float length)
		{
			return Clamp(t - Floor(t / length) * length, 0f, length);
		}

		public static float LerpAngle(float a, float b, float t)
		{
			float num = Repeat(b - a, 360f);
			if (num > 180f)
			{
				num -= 360f;
			}
			return a + num * Clamp01(t);
		}
	}
}
namespace AILimitCoop.UI
{
	public sealed class ChatLine
	{
		public string Name = "Player";

		public string Text = "";

		public uint Accent = 12297593u;

		public double At;

		public float Opacity = 1f;

		internal float WrapWidth = -1f;

		internal float NameWidth;

		internal string First;

		internal string Second;
	}
	public sealed class ChatLog
	{
		public const int Capacity = 40;

		public const int MaxLength = 96;

		public const int ClosedLines = 5;

		public const int OpenLines = 8;

		public const double VisibleSeconds = 12.0;

		public const double FadeSeconds = 2.0;

		private readonly List<ChatLine> _lines = new List<ChatLine>(40);

		public int Count => _lines.Count;

		public void Add(string name, uint accent, string text, double now)
		{
			text = CleanMessage(text);
			if (text.Length != 0)
			{
				ChatLine chatLine;
				if (_lines.Count == 40)
				{
					chatLine = _lines[0];
					_lines.RemoveAt(0);
				}
				else
				{
					chatLine = new ChatLine();
				}
				chatLine.Name = PartyPresentation.Clean(name, 24);
				chatLine.Text = text;
				chatLine.Accent = accent;
				chatLine.At = now;
				chatLine.Opacity = 1f;
				chatLine.WrapWidth = -1f;
				chatLine.First = (chatLine.Second = null);
				_lines.Add(chatLine);
			}
		}

		public void Clear()
		{
			_lines.Clear();
		}

		public void Visible(List<ChatLine> into, double now, bool open)
		{
			into.Clear();
			for (int i = Math.Max(0, _lines.Count - (open ? 8 : 5)); i < _lines.Count; i++)
			{
				ChatLine chatLine = _lines[i];
				chatLine.Opacity = (open ? 1f : Fade(now - chatLine.At));
				if (chatLine.Opacity > 0f)
				{
					into.Add(chatLine);
				}
			}
		}

		public static float Fade(double age)
		{
			if (!(age >= 12.0))
			{
				if (!(age <= 10.0))
				{
					return (float)((12.0 - age) / 2.0);
				}
				return 1f;
			}
			return 0f;
		}

		public static string CleanMessage(string text, int maxElements = 96)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder(Math.Min(text.Length, maxElements * 2));
			TextElementEnumerator textElementEnumerator = StringInfo.GetTextElementEnumerator(text.Trim());
			int num = 0;
			while (num < maxElements && textElementEnumerator.MoveNext())
			{
				string textElement = textElementEnumerator.GetTextElement();
				if (char.IsControl(textElement, 0))
				{
					if (stringBuilder.Length > 0 && stringBuilder[stringBuilder.Length - 1] != ' ')
					{
						stringBuilder.Append(' ');
						num++;
					}
				}
				else
				{
					stringBuilder.Append(textElement);
					num++;
				}
			}
			return stringBuilder.ToString().Trim();
		}
	}
	public sealed class ChatKeyGate
	{
		public bool Armed { get; private set; }

		public void Opened()
		{
			Armed = false;
		}

		public void Closed()
		{
			Armed = false;
		}

		public void Observe(bool keyHeld)
		{
			if (!keyHeld)
			{
				Armed = true;
			}
		}
	}
	public sealed class ChatSendLimiter
	{
		public const double Interval = 0.35;

		private double _last = double.NegativeInfinity;

		public bool TryAcquire(double now)
		{
			if (now - _last < 0.35)
			{
				return false;
			}
			_last = now;
			return true;
		}
	}
	public sealed class CoopUI
	{
		private sealed class PeerView
		{
			public Peer Peer;

			public readonly PartyMemberView View = new PartyMemberView();

			public int DetailKind = -1;

			public int DetailDistance = -1;

			public int DetailPing = -1;

			public float HealthHp = float.NaN;

			public float HealthMax = float.NaN;
		}

		private struct AllyBarPlacement
		{
			public float Distance;

			public float X;

			public float Y;

			public float Width;

			public float Opacity;

			public float NameOpacity;

			public float Health;

			public float Trail;

			public string Name;
		}

		private const float DefaultCharacterHeight = 1.7f;

		private const float AllyBarClearance = 0.2f;

		private const float ChatLeft = 28f;

		private const float ChatBottomMargin = 180f;

		private const string ChatControlName = "AILimitCoopChat";

		private static readonly Color White = Il2CppUtil.MakeColor(1f, 1f, 1f, 1f);

		private readonly CoopRuntime _rt;

		private readonly List<(string text, float until)> _notices = new List<(string, float)>();

		private readonly List<PartyMemberView> _members = new List<PartyMemberView>(16);

		private readonly List<PartyMemberView> _allies = new List<PartyMemberView>(15);

		private readonly Dictionary<byte, PeerView> _peerViews = new Dictionary<byte, PeerView>();

		private readonly List<byte> _departed = new List<byte>();

		private readonly PartyMemberView _local = new PartyMemberView();

		private float _localHealthHp = float.NaN;

		private float _localHealthMax = float.NaN;

		private readonly List<AllyBarPlacement> _allyBars = new List<AllyBarPlacement>(15);

		private readonly ChatLog _chat = new ChatLog();

		private readonly List<ChatLine> _chatLines = new List<ChatLine>(8);

		private readonly ChatKeyGate _chatGate = new ChatKeyGate();

		private readonly ChatSendLimiter _chatLimiter = new ChatSendLimiter();

		private UnityPartyCanvas _canvas;

		private GUIStyle _buttonStyle;

		private GUIStyle _fieldStyle;

		private GUIStyle _chatFieldStyle;

		private string _address;

		private string _chatDraft = "";

		private float _nextViewRefresh;

		private float _lastViewRefresh;

		private float _nextNameRefresh;

		private string _localName = "Player";

		private bool _details;

		private int _partyPage;

		private bool _managePlayers;

		private bool _showBans;

		private int _moderationPage;

		private readonly List<PartyModerationRow> _moderationRows = new List<PartyModerationRow>();

		private readonly List<Peer> _moderationPeers = new List<Peer>();

		private readonly List<ulong> _moderationIds = new List<ulong>();

		private bool _fieldUnavailable;

		private bool _chatFieldUnavailable;

		private float _styleRetryAt;

		private bool _menuPainted;

		private float _measuredHeight;

		private float _nextHeightSample;

		private bool _allyBarErrorLogged;

		private bool _chatErrorLogged;

		private Vector2 _mouse;

		private (bool Active, bool Host, bool Connected, bool Steam, int Rtt) _connectionKey = (Active: false, Host: false, Connected: false, Steam: false, Rtt: int.MinValue);

		private string _connectionText = "OFFLINE";

		private int _menuKeyValue = int.MinValue;

		private string _menuKeyText = "";

		private string _spectatorFor;

		private string _spectatorText = "";

		public bool HasStyles => _canvas != null;

		public bool ChatOpen { get; private set; }

		private static float BaseScale => UnityMath.Clamp((float)Screen.height / 1080f, 0.8f, 3f);

		public bool CanChat
		{
			get
			{
				if (CoopConfig.ShowChat.Value && CoopConfig.EnableOverlay.Value && HasStyles && OverlayHost.IsAlive && _rt.Session.IsConnected && _rt.GameActive && !_rt.Loading && !_rt.MenuVisible)
				{
					return !NativeMenuOpen();
				}
				return false;
			}
		}

		private static float ChatScale => BaseScale * CoopConfig.HudScale.Value;

		public CoopUI(CoopRuntime rt)
		{
			_rt = rt;
		}

		public void Notify(string text)
		{
			Notify(text, text);
		}

		public void Notify(string text, string logText)
		{
			Log.Msg("[UI] " + logText);
			_notices.Add((PartyPresentation.Clean(text, 180), Time.realtimeSinceStartup + 6f));
			if (_notices.Count > 3)
			{
				_notices.RemoveAt(0);
			}
		}

		private bool EnsureStyles()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_009e: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00fc: 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_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			if (_canvas != null)
			{
				return true;
			}
			if (Time.realtimeSinceStartup < _styleRetryAt)
			{
				return false;
			}
			try
			{
				Color textColor = UnityPartyCanvas.ColorOf(15262937u);
				_buttonStyle = new GUIStyle();
				_buttonStyle.richText = false;
				_fieldStyle = new GUIStyle();
				_fieldStyle.fontSize = 13;
				_fieldStyle.alignment = (TextAnchor)3;
				_fieldStyle.clipping = (TextClipping)1;
				_fieldStyle.richText = false;
				_fieldStyle.padding = new RectOffset(10, 10, 0, 0);
				_fieldStyle.normal.textColor = textColor;
				_fieldStyle.focused.textColor = textColor;
				_chatFieldStyle = new GUIStyle();
				_chatFieldStyle.fontSize = 12;
				_chatFieldStyle.alignment = (TextAnchor)3;
				_chatFieldStyle.clipping = (TextClipping)1;
				_chatFieldStyle.richText = false;
				_chatFieldStyle.normal.textColor = textColor;
				_chatFieldStyle.focused.textColor = textColor;
				_chatFieldStyle.hover.textColor = textColor;
				_chatFieldStyle.active.textColor = textColor;
				_canvas = new UnityPartyCanvas();
				return true;
			}
			catch (Exception ex)
			{
				_styleRetryAt = Time.realtimeSinceStartup + 10f;
				Log.Warn("[UI] styles: " + ex.Message);
				return false;
			}
		}

		public void Draw(bool trace = false)
		{
			//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_0149: 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_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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if (trace)
			{
				Log.Trace("UI: party styles");
			}
			if (!EnsureStyles())
			{
				return;
			}
			RefreshParty();
			Matrix4x4 matrix = GUI.matrix;
			Color color = GUI.color;
			Color contentColor = GUI.contentColor;
			Color backgroundColor = GUI.backgroundColor;
			bool enabled = GUI.enabled;
			try
			{
				GUI.color = (GUI.contentColor = (GUI.backgroundColor = White));
				GUI.enabled = true;
				_canvas.BeginPass();
				bool repaint = _canvas.Repaint;
				if (!_rt.MenuVisible)
				{
					_menuPainted = false;
				}
				if (repaint)
				{
					DrawAllyBars();
					if (CoopConfig.ShowHud.Value && !_rt.MenuVisible)
					{
						DrawHud();
					}
					if (!_rt.MenuVisible)
					{
						DrawChatFeed();
					}
				}
				if (_rt.MenuVisible)
				{
					bool num = !_menuPainted && repaint;
					if (num)
					{
						Log.Info("[UI] party menu first repaint starting");
					}
					DrawMenu();
					if (num)
					{
						_menuPainted = true;
						Log.Info("[UI] party menu first repaint complete");
					}
				}
				if (ChatOpen)
				{
					DrawChatInput();
				}
				if (repaint)
				{
					if (_rt.Life.IsSpectating && !_rt.MenuVisible)
					{
						DrawSpectator();
					}
					DrawNotices();
				}
			}
			finally
			{
				GUI.matrix = matrix;
				GUI.color = color;
				GUI.contentColor = contentColor;
				GUI.backgroundColor = backgroundColor;
				GUI.enabled = enabled;
			}
		}

		private void RefreshParty()
		{
			//IL_0095: 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_0090: 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_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup < _nextViewRefresh)
			{
				return;
			}
			float dt = UnityMath.Clamp(realtimeSinceStartup - _lastViewRefresh, 0f, 0.3f);
			_lastViewRefresh = realtimeSinceStartup;
			_nextViewRefresh = realtimeSinceStartup + 0.1f;
			Session session = _rt.Session;
			_members.Clear();
			_allies.Clear();
			Player val = ((_rt.GameActive && !GameState.IsLoadingLevel) ? GameState.LocalPlayer : null);
			bool flag = (Object)(object)val != (Object)null;
			Vector3 a = (Vector3)(flag ? GameState.SafePosition(val) : default(Vector3));
			if (realtimeSinceStartup >= _nextNameRefresh)
			{
				_nextNameRefresh = realtimeSinceStartup + 2f;
				_localName = CoopConfig.EffectivePlayerName;
			}
			_local.Name = _localName;
			_local.Role = (session.IsHost ? "YOU / HOST" : "YOU");
			_local.Accent = PartyTheme.Accent(session.IsActive ? session.LocalPeerId : 0);
			_local.Status = (flag ? "READY" : "NOT IN WORLD");
			_local.StatusColor = (flag ? 13225156u : 11184543u);
			_local.Detail = (session.IsHost ? "Leading the party" : (session.IsConnected ? "Connected to host" : "Your character"));
			SetHealth(_local, flag ? GameState.SafeHp(val) : 0f, flag ? GameState.SafeHpMax(val) : 0f, flag, dt, ref _localHealthHp, ref _localHealthMax);
			if (_local.HealthKnown && _local.Health <= 0f)
			{
				_local.Status = "DEAD";
				_local.StatusColor = 13994619u;
			}
			if (_rt.Life.IsSpectating)
			{
				_local.Status = "SPECTATING";
			}
			_members.Add(_local);
			_departed.Clear();
			foreach (KeyValuePair<byte, PeerView> peerView in _peerViews)
			{
				if (session.GetPeer(peerView.Key) != peerView.Value.Peer)
				{
					_departed.Add(peerView.Key);
				}
			}
			foreach (byte item in _departed)
			{
				_peerViews.Remove(item);
			}
			IReadOnlyList<Peer> peers = session.Peers;
			for (int i = 0; i < peers.Count; i++)
			{
				Peer peer = peers[i];
				if (!_peerViews.TryGetValue(peer.Id, out var value))
				{
					value = new PeerView
					{
						Peer = peer
					};
					_peerViews[peer.Id] = value;
				}
				PartyMemberView view = value.View;
				PlayerStateMsg lastState = peer.LastState;
				bool flag2 = peer.LastStateReceivedAt >= 0f && session.Now - peer.LastStateReceivedAt > 3f;
				bool flag3 = lastState == null || (lastState.Flags & PlayerFlags.Loading) != 0;
				bool flag4 = flag && lastState != null && lastState.LevelId == _rt.LevelId;
				bool flag5 = lastState != null && (lastState.Flags & PlayerFlags.Dead) != 0;
				view.Name = peer.Name;
				view.Role = ((peer.Id == 0) ? "HOST" : "ALLY");
				view.Accent = PartyTheme.Accent(peer.Id);
				view.StatusColor = 13225156u;
				if (flag2)
				{
					view.Status = "CONNECTION SLOW";
					view.StatusColor = 12954232u;
				}
				else if (flag3)
				{
					view.Status = "LOADING";
					view.StatusColor = 11184543u;
				}
				else if (flag5)
				{
					view.Status = (((lastState.Flags & PlayerFlags.Spectating) != PlayerFlags.None) ? "SPECTATING" : "DEAD");
					view.StatusColor = 13994619u;
				}
				else if ((lastState.Flags & PlayerFlags.InCombat) != PlayerFlags.None)
				{
					view.Status = "IN COMBAT";
					view.StatusColor = 12954232u;
				}
				else
				{
					view.Status = "EXPLORING";
				}
				int num = ((!flag3) ? ((!flag) ? 1 : ((!flag4) ? 2 : 3)) : 0);
				int num2 = -1;
				if (flag4 && !flag3 && !flag2)
				{
					float num3 = UnityMath.Sqrt(Il2CppUtil.SqrDistance(a, Il2CppUtil.MakeVec3(lastState.X, lastState.Y, lastState.Z)));
					if (float.IsFinite(num3))
					{
						num = 4;
						num2 = (int)UnityMath.Clamp(num3, 0f, 9999f);
					}
				}
				int num4 = (session.IsHost ? peer.RttMs : ((peer.Id == 0) ? session.HostRttMs : (-1)));
				if (num4 <= 0)
				{
					num4 = -1;
				}
				if (num != value.DetailKind || num2 != value.DetailDistance || num4 != value.DetailPing)
				{
					value.DetailKind = num;
					value.DetailDistance = num2;
					value.DetailPing = num4;
					string text = num switch
					{
						0 => "Waiting for player", 
						1 => "In the world", 
						2 => "In another area", 
						4 => num2 + " m away", 
						_ => "In your area", 
					};
					view.Detail = ((num4 > 0) ? (text + "  /  " + num4 + " ms") : text);
				}
				SetHealth(view, lastState?.Hp ?? 0f, lastState?.HpMax ?? 0f, !flag3 && !flag2, dt, ref value.HealthHp, ref value.HealthMax);
				if (view.HealthKnown && view.Health <= 0.25f && !flag5 && !flag2)
				{
					view.Status = "LOW HEALTH";
					view.StatusColor = 13994619u;
				}
				_allies.Add(view);
				_members.Add(view);
			}
		}

		private static void SetHealth(PartyMemberView view, float hp, float max, bool known, float dt, ref float textHp, ref float textMax)
		{
			bool healthKnown = view.HealthKnown;
			view.HealthKnown = known && float.IsFinite(hp) && float.IsFinite(max) && max > 0f;
			view.Health = (view.HealthKnown ? PartyPresentation.Fraction(hp, max) : 0f);
			view.Trail = ((!healthKnown || !view.HealthKnown) ? view.Health : UnityMath.MoveTowards(view.Trail, view.Health, dt * 0.55f));
			view.Trail = UnityMath.Max(view.Trail, view.Health);
			float num = (view.HealthKnown ? Math.Clamp(hp, 0f, max) : float.NaN);
			float num2 = (view.HealthKnown ? max : float.NaN);
			if (!num.Equals(textHp) || !num2.Equals(textMax))
			{
				textHp = num;
				textMax = num2;
				view.HealthText = (view.HealthKnown ? (num.ToString("N0") + " / " + max.ToString("N0")) : "--");
			}
		}

		private string ConnectionText()
		{
			Session session = _rt.Session;
			(bool, bool, bool, bool, int) tuple = (session.IsActive, session.IsHost, session.IsConnected, session.Transport is SteamP2PTransport, (!session.IsHost) ? session.HostRttMs : 0);
			(bool, bool, bool, bool, int) tuple2 = tuple;
			(bool, bool, bool, bool, int) connectionKey = _connectionKey;
			if (tuple2.Item1 == connectionKey.Item1 && tuple2.Item2 == connectionKey.Item2 && tuple2.Item3 == connectionKey.Item3 && tuple2.Item4 == connectionKey.Item4 && tuple2.Item5 == connectionKey.Item5)
			{
				return _connectionText;
			}
			_connectionKey = tuple;
			string text = (tuple.Item4 ? "STEAM" : "DIRECT");
			_connectionText = ((!session.IsActive) ? "OFFLINE" : ((!session.IsHost && !session.IsConnected) ? "CONNECTING" : (session.IsHost ? ("HOSTING  /  " + text) : (text + "  /  " + ((session.HostRttMs > 0) ? (session.HostRttMs + " ms") : "CONNECTED")))));
			return _connectionText;
		}

		private string MenuKeyText()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected I4, but got Unknown
			//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)
			int num = (int)CoopConfig.ToggleMenuKey.Value;
			if (num == _menuKeyValue)
			{
				return _menuKeyText;
			}
			_menuKeyValue = num;
			_menuKeyText = ((object)CoopConfig.ToggleMenuKey.Value/*cast due to .constrained prefix*/).ToString();
			return _menuKeyText;
		}

		private static void Scale(float scale)
		{
			//IL_0002: 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)
			GUI.matrix = new Matrix4x4
			{
				m00 = scale,
				m11 = scale,
				m22 = 1f,
				m33 = 1f
			};
		}

		private void DrawHud()
		{
			if (_rt.Session.IsActive)
			{
				float num = PartyPresentation.HudHeight(_allies.Count);
				float num2 = PartyPresentation.HudScale(Screen.width, Screen.height, CoopConfig.HudScale.Value, _allies.Count);
				Scale(num2);
				float num3 = (float)Screen.width / num2;
				float num4 = (float)Screen.height / num2;
				float num5 = 20f;
				PartyHudCorner value = CoopConfig.HudCorner.Value;
				bool flag = value == PartyHudCorner.TopRight || value == PartyHudCorner.BottomRight;
				bool flag2 = value == PartyHudCorner.BottomRight || value == PartyHudCorner.BottomLeft;
				PartyPresentation.Hud(_canvas, flag ? (num3 - 292f - num5) : num5, flag2 ? (num4 - num - num5) : num5, _allies, ConnectionText(), MenuKeyText(), CoopConfig.HudOpacity.Value);
			}
		}

		private void DrawMenu()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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)
			float b = UnityMath.Min(BaseScale, UnityMath.Min(((float)Screen.width - 32f) / 860f, ((float)Screen.height - 32f) / 682f));
			b = UnityMath.Max(0.25f, b);
			Scale(b);
			_mouse = Event.current.mousePosition;
			float num = (float)Screen.width / b;
			float num2 = (float)Screen.height / b;
			float num3 = (num - 860f) / 2f;
			float num4 = (num2 - 682f) / 2f;
			_canvas.Fill(0f, 0f, num, num2, 395016u, 0.58f);
			string footer = (_details ? $"Build {"0.2.4"}  /  Hooks {Hooks.Applied}/{Hooks.Applied + Hooks.Failed}  /  Enemies {_rt.MonsterClient.ControlledCount}  /  {_rt.Session.StatusText}" : (((object)CoopConfig.ToggleMenuKey.Value/*cast due to .constrained prefix*/).ToString() + "  party menu    /    " + ((object)CoopConfig.LeaveKey.Value/*cast due to .constrained prefix*/).ToString() + "  leave session"));
			PartyPresentation.MenuFrame(_canvas, num3, num4, ConnectionText(), _rt.Session.IsActive, footer, _rt.LastError, _rt.GameActive && !GameState.IsLoadingLevel);
			if (Button(num3 + 758f, num4 + 24f, 78f, 42f, "CLOSE"))
			{
				_rt.MenuVisible = false;
			}
			DrawConnections(num3 + 24f, num4 + 110f);
			if (_rt.Session.IsClient)
			{
				_managePlayers = false;
			}
			if (_managePlayers)
			{
				DrawModeration(num3 + 304f, num4 + 110f);
			}
			else
			{
				DrawPartyRoster(num3, num4);
			}
			DrawHudSettings(num3 + 24f, num4 + 575f);
			if (Button(num3 + 622f, num4 + 575f, 76f, 30f, "PLAYERS", primary: false, !_rt.Session.IsClient))
			{
				_managePlayers = !_managePlayers;
			}
			if (Button(num3 + 708f, num4 + 575f, 128f, 30f, _details ? "HIDE DETAILS" : "DETAILS"))
			{
				_details = !_details;
			}
		}

		private void DrawAllyBars()
		{
			try
			{
				if (CollectAllyBars(out var scale) == null)
				{
					Scale(scale);
					float viewWidth = (float)Screen.width / scale;
					for (int i = 0; i < _allyBars.Count; i++)
					{
						AllyBarPlacement allyBarPlacement = _allyBars[i];
						PartyPresentation.AllyBar(_canvas, allyBarPlacement.X, allyBarPlacement.Y, allyBarPlacement.Width, allyBarPlacement.Health, allyBarPlacement.Trail, allyBarPlacement.Opacity);
						PartyPresentation.AllyName(_canvas, allyBarPlacement.X, allyBarPlacement.Y, viewWidth, allyBarPlacement.Name, allyBarPlacement.NameOpacity);
					}
				}
			}
			catch (Exception ex)
			{
				if (!_allyBarErrorLogged)
				{
					_allyBarErrorLogged = true;
					Log.Warn("[UI] ally health bars unavailable: " + ex.Message);
				}
			}
		}

		private string CollectAllyBars(out float scale)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: 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_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: 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_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			_allyBars.Clear();
			scale = 1f;
			if (!CoopConfig.AllyHealthBars.Value)
			{
				return "disabled";
			}
			if (_rt.MenuVisible)
			{
				return "co-op menu open";
			}
			if (!_rt.Session.IsActive || !_rt.GameActive || _rt.Loading)
			{
				return "not in a session world";
			}
			if (_rt.Ghosts.Count == 0)
			{
				return "no allies";
			}
			if (!GameShowsHealthBars())
			{
				return "game hid its health bars";
			}
			Camera val = GameCamera();
			if ((Object)(object)val == (Object)null)
			{
				return "no camera";
			}
			scale = BaseScale * CoopConfig.HudScale.Value;
			Vector3 position = ((Component)val).transform.position;
			float num = CharacterHeight() + 0.2f;
			float value = CoopConfig.AllyHealthBarDistance.Value;
			bool value2 = CoopConfig.AllyHealthBarNames.Value;
			float screenWidth = Screen.width;
			float screenHeight = Screen.height;
			IReadOnlyList<RemotePlayer> all = _rt.Ghosts.All;
			for (int i = 0; i < all.Count; i++)
			{
				Remo