using System;
using System.Collections;
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 AtmosphericHeightFog;
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 Bullets;
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 Logic.BossRush;
using Logic.RoguelikeAbility;
using Microsoft.CodeAnalysis;
using MonsterGroupManager;
using PlayerShowSateDefine;
using ProtoUtility;
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.Playables;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;

[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.3.10.0")]
[assembly: AssemblyInformationalVersion("0.3.8")]
[assembly: AssemblyProduct("AI LIMIT Co-op")]
[assembly: AssemblyTitle("AILimitCoop")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.10.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<bool> SyncEnemyBreakState;

		public static ConfigEntry<bool> SyncEnemyEffects;

		public static ConfigEntry<bool> SyncPlayerEffects;

		public static ConfigEntry<bool> SyncPlayerProjectiles;

		public static ConfigEntry<bool> SyncPlayerWorldEffects;

		public static ConfigEntry<bool> SyncRogueLayout;

		public static ConfigEntry<bool> AssistBossWake;

		public static ConfigEntry<bool> SyncRogueTrials;

		public static ConfigEntry<bool> SyncRogueStageExits;

		public static ConfigEntry<bool> SyncExecutions;

		public static ConfigEntry<bool> SyncRoomClears;

		public static ConfigEntry<float> EnemyHpPerExtraPlayer;

		public static ConfigEntry<DifficultyPreset> Difficulty;

		public static ConfigEntry<float> BossHpPerExtraPlayer;

		public static ConfigEntry<float> BreakResistPerExtraPlayer;

		public static ConfigEntry<bool> AllowPvp;

		public static ConfigEntry<PvpDamagePreset> PvpDamage;

		public static ConfigEntry<bool> PvpArena;

		public static ConfigEntry<bool> GhostTargeting;

		public static ConfigEntry<HitDetectionMode> HitDetection;

		public static ConfigEntry<bool> GhostEquipment;

		public static ConfigEntry<bool> GhostCollision;

		public static ConfigEntry<bool> ShowFallenPlayers;

		public static ConfigEntry<bool> SyncWeakPoints;

		public static ConfigEntry<bool> ShowAllySync;

		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 const string DevFileName = "com.ailimit.coop.dev.cfg";

		public static DifficultySettings EffectiveDifficulty => CoopDifficulty.For(Difficulty.Value, EnemyHpPerExtraPlayer.Value, BossHpPerExtraPlayer.Value, BreakResistPerExtraPlayer.Value);

		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 bool DevFile { get; private set; }

		public static int RetiredDropped { get; private set; }

		public static void Bind(ConfigFile cfg)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Expected O, but got Unknown
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Expected O, but got Unknown
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Expected O, but got Unknown
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Expected O, but got Unknown
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Expected O, but got Unknown
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: Expected O, but got Unknown
			//IL_047d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: Expected O, but got Unknown
			//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: Expected O, but got Unknown
			//IL_067e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0688: Expected O, but got Unknown
			//IL_06b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c0: Expected O, but got Unknown
			//IL_073f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0749: Expected O, but got Unknown
			//IL_0831: Unknown result type (might be due to invalid IL or missing references)
			//IL_083b: Expected O, but got Unknown
			//IL_0861: Unknown result type (might be due to invalid IL or missing references)
			//IL_086b: Expected O, but got Unknown
			//IL_088e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0898: Expected O, but got Unknown
			string text = Path.Combine(Path.GetDirectoryName(cfg.ConfigFilePath) ?? "", "com.ailimit.coop.dev.cfg");
			DevFile = File.Exists(text);
			ConfigFile val = new ConfigFile(text, false)
			{
				SaveOnConfigSet = false
			};
			bool flag = false;
			try
			{
				flag = File.Exists(cfg.ConfigFilePath) && !Regex.IsMatch(File.ReadAllText(cfg.ConfigFilePath), "^\\s*Difficulty\\s*=", RegexOptions.Multiline);
			}
			catch (IOException)
			{
			}
			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: host and join through your Steam friends list - no address or port forwarding needed.");
			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 = val.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 = val.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 = val.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 = val.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 = val.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 = val.Bind<float>("Network", "GhostAnimCrossFade", 0.06f, "Seconds to fade when another player's animation state changes, instead of cutting. 0 disables.");
			SyncMonsters = val.Bind<bool>("Gameplay", "SyncMonsters", true, "Share enemies, so everyone fights the same ones. Off: each player fights their own copy of every enemy and only the players themselves are shared.");
			SyncEnemyBreakState = val.Bind<bool>("Gameplay", "SyncEnemyBreakState", true, "Show the stagger gauge of enemies another player's game runs, and break them when it breaks there, so an execution can be offered. Disable if a broken enemy misbehaves on your machine.");
			SyncEnemyEffects = val.Bind<bool>("Gameplay", "SyncEnemyEffects", true, "Show the attack effects, attack sounds and weapon trails of enemies that another player's game runs. Cosmetic only; disable if it causes problems.");
			SyncPlayerEffects = val.Bind<bool>("Gameplay", "SyncPlayerEffects", true, "Show the spell, skill and weapon-art effects of the other players. Cosmetic only.");
			SyncPlayerProjectiles = val.Bind<bool>("Gameplay", "SyncPlayerProjectiles", true, new ConfigDescription("Show the flying projectiles of other players' spells and skills. The copy is visual only: it cannot hit anyone, and damage is unaffected.", (AcceptableValueBase)null, Array.Empty<object>()));
			SyncPlayerWorldEffects = val.Bind<bool>("Gameplay", "SyncPlayerWorldEffects", true, new ConfigDescription("Show the effects other players' abilities put into the world: a lightning strike where it was aimed, its impact, a buff flash, a weapon art's slash, a spell's flames on their blade. Visual only.", (AcceptableValueBase)null, Array.Empty<object>()));
			SyncRogueLayout = val.Bind<bool>("Gameplay", "SyncRogueLayout", true, "Furnace of War: every player fights the same rooms in a run, and the second stage is made of the same maps for everyone. Off makes each game roll its own, and each player then plays every stage alone.");
			AssistBossWake = val.Bind<bool>("Gameplay", "AssistBossWake", true, "While the host is dead and spectating, a boss starts for the living player standing in front of it. Off leaves a run unfinishable once the host is down.");
			SyncRoomClears = val.Bind<bool>("Gameplay", "SyncRoomClears", true, "When a DLC room is cleared on another player's game and not on yours - a Furnace room whose doors stay shut, a Boss Rush room with no exit rift - open it on yours too.");
			SyncRogueTrials = val.Bind<bool>("Gameplay", "SyncRogueTrials", true, "Furnace of War: a spectating player's game enters a trial when a teammate does, so the arena and its boss exist for the game that simulates them. Living players always enter their own.");
			SyncRogueStageExits = val.Bind<bool>("Gameplay", "SyncRogueStageExits", true, "Furnace of War: when a teammate takes the portal to the next stage while you are down, you get up and follow them instead of being left behind, which ended your run. Living players are told and take the portal themselves.");
			SyncExecutions = val.Bind<bool>("Gameplay", "SyncExecutions", true, "An execution (finisher) of a broken enemy, or a backstab, on an enemy that another player's game runs deals your damage there. Without it they do no damage. Executions are new in 0.3.0 and backstabs in 0.3.1; turn it off if either misbehaves in co-op.");
			Difficulty = cfg.Bind<DifficultyPreset>("Gameplay", "Difficulty", DifficultyPreset.Balanced, "Host setting, shared when players join. How much tougher enemies get for each extra player in the same area. Balanced: enemies +75% and bosses +100% HP per extra player, stagger/sync-rate breaks +50% harder per extra player. Hard: enemies +100%, bosses +150%, breaks +100% harder. Challenge: enemies +150%, bosses +200%, breaks +150% harder. Custom: the three values below. Change before hosting a new session.");
			EnemyHpPerExtraPlayer = cfg.Bind<float>("Gameplay", "EnemyHpPerExtraPlayer", 0.5f, new ConfigDescription("Difficulty = Custom only. Extra HP for ordinary enemies per extra player in the area: 0.5 = +50%, 0 disables. Combat locks the maximum until rest/reset.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			BossHpPerExtraPlayer = cfg.Bind<float>("Gameplay", "BossHpPerExtraPlayer", 1f, new ConfigDescription("Difficulty = Custom only. Extra HP for bosses and mini-bosses per extra player in the area: 1 = +100%.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			BreakResistPerExtraPlayer = cfg.Bind<float>("Gameplay", "BreakResistPerExtraPlayer", 0.5f, new ConfigDescription("Difficulty = Custom only. How much slower enemies stagger and lose sync rate per extra player: damage to those gauges is divided by 1 + this x (players - 1). 0 = the game's own rate.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			if (flag && Math.Abs(EnemyHpPerExtraPlayer.Value - 0.5f) > 0.001f)
			{
				Difficulty.Value = DifficultyPreset.Custom;
				BossHpPerExtraPlayer.Value = EnemyHpPerExtraPlayer.Value;
				BreakResistPerExtraPlayer.Value = 0f;
			}
			AllowPvp = cfg.Bind<bool>("Gameplay", "AllowPvp", true, "Host setting, shared when players join. Lets players turn PvP on for themselves (party menu, Rules). PvP only ever applies between two players who have both turned it on, and it starts off in every session. Off: no one in your sessions can turn it on.");
			PvpDamage = cfg.Bind<PvpDamagePreset>("Gameplay", "PvpDamage", PvpDamagePreset.Standard, "Host setting, shared when players join. How hard players hit each other in PvP, as a share of an attack's usual damage (player attacks are tuned for fighting enemies, so at full strength a few hits end a duel). Low: weapons 35%, spells and items 20%. Standard: weapons 50%, spells and items 30%. High: weapons 75%, spells and items 50%. Full: 100% (enemy-strength damage).");
			PvpArena = cfg.Bind<bool>("Gameplay", "PvpArena", true, "Lists the PvP Arena in the teleport menu of every rest point (under PvP): a walled floor high above the Southwest with its own rest point, for duels. Rest there to teleport back out. Saves made in the arena resume at the rest point you came from.");
			GhostTargeting = val.Bind<bool>("Gameplay", "GhostTargeting", true, "Enemies pick which player to attack by who hurts them and who is close, as they would among allies in the base game. Off: an enemy only attacks the player whose game runs it.");
			HitDetection = val.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 = val.Bind<bool>("Gameplay", "GhostEquipment", true, "Show other players' armour and weapons. Turn off if other players' characters fail to appear.");
			ShowFallenPlayers = val.Bind<bool>("Gameplay", "ShowFallenPlayers", true, "When another player dies, their character stays where they fell and turns to mud like a death in the game, then disappears until they are revived. Turn off to keep the old behaviour.");
			SyncWeakPoints = val.Bind<bool>("Gameplay", "SyncWeakPoints", false, "Experimental, host only: share boss weak points (shields and crystals on some bosses) so breaking one breaks it for everyone. Every player follows the host's setting. Off by default until it has been tested in a real fight.");
			GhostCollision = val.Bind<bool>("Gameplay", "GhostCollision", false, "Players physically block each other instead of passing through one another.");
			ForceRunInBackground = val.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 = val.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.");
			ShowAllySync = cfg.Bind<bool>("UI", "ShowAllySync", true, "Show each teammate's sync rate as a thin blue bar under their health, on the party cards and above their head.");
			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 = val.Bind<bool>("Debug", "Verbose", false, "Log per-hit and per-spawn diagnostics to BepInEx/LogOutput.log.");
			DevCommands = val.Bind<bool>("Debug", "DevCommands", false, "Poll <GameDir>/BepInEx/coop_cmd.txt for developer commands (host, join, leave, dump, ...). Development aid only.");
			PatchGroups = val.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 = val.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 = val.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 = val.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>()));
			DropRetired(cfg);
			Log.Info("[Config] advanced settings " + (DevFile ? "read from com.ailimit.coop.dev.cfg" : "at their defaults") + ((RetiredDropped > 0) ? $"; {RetiredDropped} unused entries removed from the config file" : ""));
		}

		private static void DropRetired(ConfigFile cfg)
		{
			try
			{
				if (AccessTools.Property(typeof(ConfigFile), "OrphanedEntries")?.GetValue(cfg) is IDictionary { Count: >0 } dictionary)
				{
					RetiredDropped = dictionary.Count;
					dictionary.Clear();
				}
			}
			catch (Exception ex)
			{
				Log.Warn("[Config] could not tidy the config file: " + ex.Message);
			}
		}

		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 MonsterFxSync EnemyFx;

		public readonly PlayerFxSync PlayerFx;

		public readonly PlayerProjectileSync PlayerShots;

		public readonly PlayerWorldFxSync PlayerWorldFx;

		public readonly RogueLayoutSync RogueLayout;

		public readonly BossWakeAssist BossWake;

		public readonly RogueTrialSync RogueTrial;

		public readonly RogueStageSync RogueStage;

		public readonly RoomClearSync RoomClear;

		public readonly SummonSync Summons;

		public readonly GuardianFightSync Guardians;

		public readonly WeakPointSync WeakPoints;

		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 BossProgressMirror Progress;

		public readonly PartyLife Life;

		public readonly DefenseWatch Defense = new DefenseWatch();

		public BossMusicTracker Music;

		public readonly MonsterThreat Threat;

		public readonly TeammateTriggers Triggers;

		public readonly SharedWorld World;

		public readonly BossEncounterSync Encounters;

		public readonly BossPresentationSync Presentation;

		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 bool _hostedLast;

		private int _frames;

		private readonly SessionPerformance _performance = new SessionPerformance();

		private int _hostAttempts;

		private float _nextHostAttempt;

		private bool _firstGui = true;

		private int _guiCalls;

		private const float IdleStateInterval = 0.1f;

		private float _lastStateSentAt = -10f;

		private float _sentX;

		private float _sentY;

		private float _sentZ;

		private float _sentYaw;

		private float _sentHp;

		private float _sentSync;

		private PlayerFlags _sentFlags;

		private int _sentLevel;

		private int _sentLayers;

		private readonly int[] _sentLayerHashes = new int[6];

		private byte _sentShield;

		private byte _sentEnchant;

		private readonly HashSet<byte> _apartPeers = new HashSet<byte>();

		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;
			PvpCombat.Attach(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);
			EnemyFx = new MonsterFxSync(this);
			PlayerFx = new PlayerFxSync(this);
			PlayerShots = new PlayerProjectileSync(this);
			PlayerWorldFx = new PlayerWorldFxSync(this);
			RogueLayout = new RogueLayoutSync(this);
			Session.SeparateBuild = delegate(int level, int build)
			{
				int currentLevelId = GameState.CurrentLevelId;
				return RogueLayoutSync.Separate(level, build, currentLevelId, RogueLayout.BuildOf(currentLevelId));
			};
			BossWake = new BossWakeAssist(this);
			RogueTrial = new RogueTrialSync(this);
			RogueStage = new RogueStageSync(this);
			RoomClear = new RoomClearSync(this);
			Summons = new SummonSync(this);
			Authority.PinToOwner = Summons.HelperOwnerOf;
			Guardians = new GuardianFightSync(this);
			WeakPoints = new WeakPointSync(this);
			Log.Trace("runtime ctor: sync objects");
			UI = new CoopUI(this);
			MenuFocus = new MenuInputFocus(this);
			Rewards = new BossRewardSync(this);
			Progress = new BossProgressMirror(this);
			Life = new PartyLife(this);
			Threat = new MonsterThreat(this);
			Triggers = new TeammateTriggers(this);
			World = new SharedWorld(this);
			Encounters = new BossEncounterSync(this);
			Presentation = new BossPresentationSync(this);
			Music = new BossMusicTracker(this);
			MonsterClient.ActivationTarget = Threat.RecoveryTarget;
			MonsterClient.JoinerOnlyActor = Encounters.JoinerOnlyActor;
			MonsterClient.JoinerOnlyGone = Encounters.JoinerStandInGone;
			Dev = new DevCommands(this);
			Log.Trace("runtime ctor: ui/dev");
			MenuVisible = CoopConfig.ShowMenuOnStart.Value;
			ConfigureNetworkConditions();
			Session.OnMonsterHit += HitRelay.ApplyMonsterHit;
			Session.OnGhostHit += HitRelay.ReceiveGhostHit;
			Session.OnGhostHitResult += HitRelay.ApplyGhostHitResult;
			Session.OnPeerJoined += delegate(Peer p)
			{
				_equipSent = false;
				UI.Notify(p.Name + " joined the party", $"{p} joined");
			};
			Session.OnPeerLeft += delegate(Peer p)
			{
				if (!Session.Ending)
				{
					UI.Notify(p.Name + " left the party", $"{p} left");
				}
			};
			Session.OnPeerLeft += delegate(Peer p)
			{
				HitRelay.ForgetPeer(p.Id);
			};
			Session.OnPeerLeft += delegate(Peer p)
			{
				_apartPeers.Remove(p.Id);
			};
			Session.OnChat += delegate(Peer p, string text)
			{
				UI.ReceiveChat(p, text);
			};
			Session.OnSessionStarted += delegate
			{
				_equipSent = false;
				HitRelay.ClientSideHitsObserved = false;
				_hostedLast = Session.IsHost;
				UI.Notify(Session.IsHost ? "You're hosting. Friends can join now." : "Joining the host...");
			};
			Session.LocalGameBuild = GameBuildId.Describe();
			Log.Info("[Coop] game build " + Session.LocalGameBuild);
			Session.OnGameBuildMismatch += delegate(string theirs, string ours)
			{
				UI.Notify("Players have different game versions; some effects may not show.", "[Coop] game build mismatch: theirs " + theirs + ", ours " + ours);
			};
			Session.OnSessionEnded += delegate(string reason)
			{
				HitRelay.ClearCaches();
				PvpArena.OnSessionEnded();
				_apartPeers.Clear();
				UI.ClearChat();
				string text = SessionText.EndedNotice(reason, _hostedLast);
				if (text != null)
				{
					UI.Notify(text, "[Session] ended: " + reason);
				}
			};
		}

		private void ConfigureNetworkConditions()
		{
			string environmentVariable = Environment.GetEnvironmentVariable("AILIMITCOOP_NETSIM");
			string[] parts;
			if (!string.IsNullOrWhiteSpace(environmentVariable) && CoopConfig.DevCommands.Value)
			{
				parts = environmentVariable.Split(',');
				Session.Conditioner.Configure(Part(0), Part(1), Part(2));
				Log.Warn("[Coop] developer network conditions active: " + Session.Conditioner.Diagnostics);
			}
			float Part(int i)
			{
				if (i >= parts.Length || !float.TryParse(parts[i], NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					return 0f;
				}
				return result;
			}
		}

		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");
				}
				AttackDefenseCapture.ResetScopes();
				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();
				Session.RefreshBuilds();
				WatchBuilds();
				_performance.Mark(CoopWork.Network);
				CoopMenuPause.Tick(this);
				Life.Tick(realtimeSinceStartup);
				ChestInteractionSafety.Tick(GameActive && !Loading && Session.IsConnected);
				HolidayItems.Tick(realtimeSinceStartup, this);
				_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);
					Encounters.Tick(realtimeSinceStartup);
					BossWake.Tick(realtimeSinceStartup);
					Presentation.Tick(realtimeSinceStartup);
					Music?.Tick(realtimeSinceStartup);
					Ghosts.Update(realtimeSinceStartup, _levelId, _loading);
					_performance.Mark(CoopWork.Ghosts);
					MonsterHost.Tick(realtimeSinceStartup, _levelId, _loading);
					_performance.Mark(CoopWork.MonsterSend);
					MonsterClient.Update(realtimeSinceStartup, _levelId);
					Summons.Tick(realtimeSinceStartup);
					HelperRules.Refresh(realtimeSinceStartup);
					Guardians.Tick(realtimeSinceStartup);
					WeakPoints.Tick(realtimeSinceStartup);
					EnemyFx.Tick(realtimeSinceStartup);
					int frameCount = Time.frameCount;
					Defense.Record(frameCount, realtimeSinceStartup, MonsterClient, HitRelay.PendingAttackers, PvpCombat.Duelists(Ghosts));
					HitRelay.TickTimeline(frameCount, realtimeSinceStartup);
					PvpCombat.Tick(realtimeSinceStartup);
					_performance.Mark(CoopWork.MonsterReceive);
					Threat.Tick(realtimeSinceStartup);
					Triggers.Tick(realtimeSinceStartup);
					_performance.Mark(CoopWork.Threat);
					Rewards.Tick();
					Progress.Tick();
					_performance.Mark(CoopWork.Rewards);
					PlayerFx.Tick();
					PlayerShots.Tick(realtimeSinceStartup);
					PlayerWorldFx.Tick(realtimeSinceStartup);
					_performance.Mark(CoopWork.PlayerFx);
					RoomClear.Tick(Time.realtimeSinceStartup);
					RogueLayout.Tick(Time.realtimeSinceStartup);
					RogueStage.Tick(Time.realtimeSinceStartup);
					_performance.Mark(CoopWork.Rogue);
				}
			}
			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);
				RogueLayout.LevelChanged(currentLevelId);
				RogueTrial.LevelChanged(currentLevelId);
				RogueStage.LevelChanged(currentLevelId);
				RoomClear.LevelChanged(currentLevelId);
				Summons.LevelChanged(currentLevelId);
				Guardians.LevelChanged(currentLevelId);
				WeakPoints.LevelChanged(currentLevelId);
				Authority.OnLevelChanged();
				MonsterHost.OnLevelChanged();
				MonsterIndex.Invalidate();
				HitRelay.ClearCaches();
			}
			if (isLoadingLevel != _loading)
			{
				_loading = isLoadingLevel;
				Log.Debug($"[Game] loading = {isLoadingLevel}");
			}
		}

		private bool StateIdle(PlayerStateMsg m)
		{
			if (m.LevelId != _sentLevel || m.Flags != _sentFlags || m.ShieldStage != _sentShield || m.Enchant != _sentEnchant)
			{
				return false;
			}
			if (Math.Abs(m.X - _sentX) > 0.01f || Math.Abs(m.Y - _sentY) > 0.01f || Math.Abs(m.Z - _sentZ) > 0.01f)
			{
				return false;
			}
			if (Math.Abs(Mathf.DeltaAngle(m.Yaw, _sentYaw)) > 0.5f || m.Hp != _sentHp || Math.Abs(m.Sync - _sentSync) > 0.05f)
			{
				return false;
			}
			if (m.LayerCount != _sentLayers)
			{
				return false;
			}
			for (int i = 0; i < m.LayerCount && i < _sentLayerHashes.Length; i++)
			{
				if (m.Layers[i].Hash != _sentLayerHashes[i])
				{
					return false;
				}
			}
			for (int j = 0; j < m.ParamCount; j++)
			{
				if (Math.Abs(m.Params[j].Value) > 0.01f && IsMovementParam(j))
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsMovementParam(int index)
		{
			return index < 3;
		}

		private void RememberSent(PlayerStateMsg m)
		{
			_sentLevel = m.LevelId;
			_sentFlags = m.Flags;
			_sentShield = m.ShieldStage;
			_sentEnchant = m.Enchant;
			_sentX = m.X;
			_sentY = m.Y;
			_sentZ = m.Z;
			_sentYaw = m.Yaw;
			_sentHp = m.Hp;
			_sentSync = m.Sync;
			_sentLayers = m.LayerCount;
			for (int i = 0; i < m.LayerCount && i < _sentLayerHashes.Length; i++)
			{
				_sentLayerHashes[i] = m.Layers[i].Hash;
			}
		}

		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;
				}
				if (Session.LocalPvp && Session.PvpAllowed)
				{
					playerFlags |= PlayerFlags.PvpOptIn;
				}
				PlayerStateMsg playerStateMsg = Sampler.Sample(_levelId, playerFlags);
				playerStateMsg.Layout = RogueLayout.BuildOf(_levelId);
				if (StateIdle(playerStateMsg) && now - _lastStateSentAt < 0.1f)
				{
					return;
				}
				_lastStateSentAt = now;
				RememberSent(playerStateMsg);
				Session.SendPlayerState(playerStateMsg);
			}
			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} reserve {playerEquipMsg.ReserveWeaponDefineId} head {playerEquipMsg.HeadId} body {playerEquipMsg.BodyId} acc {playerEquipMsg.AccessoriesId}");
				}
			}
		}

		private void WatchBuilds()
		{
			if (_apartPeers.Count == 0 && GameState.CurrentLevelId <= 0)
			{
				return;
			}
			IReadOnlyList<Peer> peers = Session.Peers;
			for (int i = 0; i < peers.Count; i++)
			{
				Peer peer = peers[i];
				bool flag = Session.IsApart(peer);
				if (flag == _apartPeers.Contains(peer.Id))
				{
					continue;
				}
				if (!flag)
				{
					_apartPeers.Remove(peer.Id);
					Log.Info($"[Rogue] {peer} is no longer in a different build of this game's stage");
					continue;
				}
				_apartPeers.Add(peer.Id);
				int reportedLevelId = peer.LastState.ReportedLevelId;
				Log.Warn($"[Rogue] {peer} is in level {reportedLevelId} too, but their game built it differently (build {peer.LastState.Layout}, this game's {RogueLayout.BuildOf(reportedLevelId)}): enemies, rooms and revives are not shared with them in this stage");
				if (peer.Id == 0)
				{
					UI.Notify("Rooms differ from the host's: you each play this stage alone.");
					continue;
				}
				UI.Notify(peer.Name + "'s rooms here differ from yours, so you each play this stage alone.", $"{peer}'s rooms differ from this game's; each plays this stage alone");
			}
		}

		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 isn't running, so this uses a direct connection.");
			}
			return new UdpTransport();
		}

		public void HostSession()
		{
			LogPrivacy.RegisterName(SteamPresence.LocalName);
			Session.LocalName = CoopConfig.EffectivePlayerName;
			Session.LocalSteamId = SteamP2PTransport.LocalSteamIdOrZero;
			Session.MaxPlayers = CoopConfig.MaxPlayers.Value;
			DifficultySettings effectiveDifficulty = CoopConfig.EffectiveDifficulty;
			Session.ConfiguredEnemyHpPerExtraPlayer = effectiveDifficulty.EnemyHp;
			Session.ConfiguredBossHpPerExtraPlayer = effectiveDifficulty.BossHp;
			Session.ConfiguredBreakResistPerExtraPlayer = effectiveDifficulty.BreakResist;
			Session.ConfiguredAllowPvp = CoopConfig.AllowPvp.Value;
			Session.ConfiguredSyncWeakPoints = CoopConfig.SyncWeakPoints.Value;
			Session.ConfiguredPvpDamage = PvpRules.DamageFor(CoopConfig.PvpDamage.Value);
			Log.Info($"[Difficulty] hosting on {CoopConfig.Difficulty.Value}: {effectiveDifficulty}; PvP " + (CoopConfig.AllowPvp.Value ? $"allowed (opt-in), damage {CoopConfig.PvpDamage.Value}: {Session.ConfiguredPvpDamage}" : "disabled"));
			INetTransport netTransport = CreateTransport();
			if (!Session.Host(netTransport, CoopConfig.EffectivePort))
			{
				UI.Notify(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 to invite friends.");
				return;
			}
			if (!SteamPresence.IsAvailable)
			{
				UI.Notify("Steam isn't running.");
				return;
			}
			SteamPresence.Advertise();
			if (!SteamPresence.OpenInviteOverlay())
			{
				UI.Notify("Couldn't open the Steam overlay. Check that it's turned on in Steam.");
			}
		}

		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(Session.StatusText);
				netTransport.Dispose();
			}
		}

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

		public void BeforeMonsterReset()
		{
			Encounters?.OnReset(GameState.CurrentLevelId);
			Summons?.OnReset();
			Presentation?.OnSceneReset();
			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");
			GameState.InvalidateFrameCache();
			MonsterIndex.Invalidate();
			HitRelay.ClearCaches();
		}

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

		public void OnGameClose()
		{
			World.Clear();
			HealthScaling.RestoreAll();
			Log.Info("[Game] ProcedureManager.CloseAllLogic -> game inactive");
			GameState.InvalidateFrameCache();
			GameActive = false;
			Life.OnGameClose();
			Threat.Clear();
			Rewards.OnGameClose();
			Progress.Clear();
			PlayerFx.Clear();
			PlayerShots.Clear();
			PlayerWorldFx.Clear();
			BossWake.Clear();
			RogueTrial.Clear();
			RoomClear.Clear();
			Summons.Clear();
			Guardians.Clear();
			WeakPoints.Clear();
			RogueLayout.OnGameClose();
			Encounters.OnGameClose();
			Presentation.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.3.10")]
	public class Plugin : BasePlugin
	{
		public const string Guid = "com.ailimit.coop";

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

		public const string Version = "0.3.10";

		public const string DisplayVersion = "0.3.10 (protocol 37)";

		private static WillRenderCanvases _frameAction;

		private static Action _beforeInput;

		public override void Load()
		{
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			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"} {"0.3.10 (protocol 37)"} loading (transport {CoopConfig.Transport.Value}, port {CoopConfig.EffectivePort})");
			Log.Info($"[Net] Protocol {37}, 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,
		PlayerFx,
		Rogue,
		Other,
		Menu,
		FrameGap,
		Count
	}
	internal sealed class FrameTimingWindow
	{
		private readonly double[] _sum = new double[14];

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

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

		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 GameBuildId
	{
		private static string _cached;

		public static string Describe()
		{
			if (_cached != null)
			{
				return _cached;
			}
			string text = "?";
			try
			{
				text = Application.version;
			}
			catch
			{
			}
			string text2 = "?";
			try
			{
				FileInfo fileInfo = new FileInfo(Path.Combine(Paths.GameRootPath, "GameAssembly.dll"));
				if (fileInfo.Exists)
				{
					text2 = fileInfo.Length.ToString();
				}
			}
			catch
			{
			}
			_cached = text + "/" + text2;
			return _cached;
		}
	}
	public sealed class GlbModel
	{
		public float[] Positions;

		public float[] Normals;

		public float[] Uvs;

		public int[] Triangles;

		public byte[] Image;

		public int VertexCount => Positions.Length / 3;

		public int TriangleCount => Triangles.Length / 3;

		public static GlbModel Read(byte[] glb)
		{
			if (glb == null || glb.Length < 28 || BitConverter.ToUInt32(glb, 0) != 1179937895)
			{
				throw new FormatException("not a binary glTF file");
			}
			int num = BitConverter.ToInt32(glb, 12);
			if (BitConverter.ToUInt32(glb, 16) != 1313821514)
			{
				throw new FormatException("the first chunk is not JSON");
			}
			int binStart = 20 + num + 8;
			if (binStart > glb.Length || BitConverter.ToUInt32(glb, 20 + num + 4) != 5130562)
			{
				throw new FormatException("no binary chunk");
			}
			JsonElement accessors;
			JsonElement views;
			using (JsonDocument jsonDocument = JsonDocument.Parse(new ReadOnlyMemory<byte>(glb, 20, num)))
			{
				JsonElement rootElement = jsonDocument.RootElement;
				accessors = rootElement.GetProperty("accessors");
				views = rootElement.GetProperty("bufferViews");
				JsonElement jsonElement = rootElement.GetProperty("meshes")[0].GetProperty("primitives")[0];
				JsonElement property = jsonElement.GetProperty("attributes");
				GlbModel glbModel = new GlbModel
				{
					Positions = Floats(property.GetProperty("POSITION").GetInt32(), 3)
				};
				if (property.TryGetProperty("NORMAL", out var value))
				{
					glbModel.Normals = Floats(value.GetInt32(), 3);
				}
				if (property.TryGetProperty("TEXCOORD_0", out var value2))
				{
					glbModel.Uvs = Floats(value2.GetInt32(), 2);
				}
				int vertexCount = glbModel.VertexCount;
				for (int i = 0; i < vertexCount; i++)
				{
					glbModel.Positions[i * 3] = 0f - glbModel.Positions[i * 3];
					if (glbModel.Normals != null)
					{
						glbModel.Normals[i * 3] = 0f - glbModel.Normals[i * 3];
					}
					if (glbModel.Uvs != null)
					{
						glbModel.Uvs[i * 2 + 1] = 1f - glbModel.Uvs[i * 2 + 1];
					}
				}
				JsonElement a = accessors[jsonElement.GetProperty("indices").GetInt32()];
				int @int = a.GetProperty("count").GetInt32();
				int int2 = a.GetProperty("componentType").GetInt32();
				int num2 = Start(a);
				int num3 = int2 switch
				{
					5123 => 2, 
					5125 => 4, 
					_ => 1, 
				};
				if (@int % 3 != 0 || num2 + @int * num3 > glb.Length)
				{
					throw new FormatException("bad index data");
				}
				glbModel.Triangles = new int[@int];
				for (int j = 0; j < @int; j += 3)
				{
					int num4 = Index(glb, num2, int2, j);
					int num5 = Index(glb, num2, int2, j + 1);
					int num6 = Index(glb, num2, int2, j + 2);
					if (num4 >= vertexCount || num5 >= vertexCount || num6 >= vertexCount)
					{
						throw new FormatException("an index points past the vertices");
					}
					glbModel.Triangles[j] = num4;
					glbModel.Triangles[j + 1] = num6;
					glbModel.Triangles[j + 2] = num5;
				}
				if (rootElement.TryGetProperty("images", out var value3) && value3.GetArrayLength() > 0 && value3[0].TryGetProperty("bufferView", out var value4))
				{
					JsonElement jsonElement2 = views[value4.GetInt32()];
					int num7 = ViewStart(value4.GetInt32());
					int int3 = jsonElement2.GetProperty("byteLength").GetInt32();
					if (num7 + int3 <= glb.Length)
					{
						glbModel.Image = new byte[int3];
						Buffer.BlockCopy(glb, num7, glbModel.Image, 0, int3);
					}
				}
				return glbModel;
			}
			float[] Floats(int index, int width)
			{
				JsonElement a2 = accessors[index];
				if (a2.GetProperty("componentType").GetInt32() != 5126)
				{
					throw new FormatException("vertex data is not float");
				}
				int num8 = a2.GetProperty("count").GetInt32() * width;
				int num9 = Start(a2);
				if (num9 < binStart || num9 + num8 * 4 > glb.Length)
				{
					throw new FormatException("vertex data outside the file");
				}
				float[] array = new float[num8];
				Buffer.BlockCopy(glb, num9, array, 0, num8 * 4);
				return array;
			}
			int Start(JsonElement jsonElement3)
			{
				JsonElement value5;
				return ViewStart(jsonElement3.GetProperty("bufferView").GetInt32()) + (jsonElement3.TryGetProperty("byteOffset", out value5) ? value5.GetInt32() : 0);
			}
			int ViewStart(int view)
			{
				JsonElement jsonElement3 = views[view];
				JsonElement value5;
				return binStart + (jsonElement3.TryGetProperty("byteOffset", out value5) ? value5.GetInt32() : 0);
			}
		}

		private static int Index(byte[] b, int offset, int type, int i)
		{
			return type switch
			{
				5125 => (int)BitConverter.ToUInt32(b, offset + i * 4), 
				5123 => BitConverter.ToUInt16(b, offset + i * 2), 
				_ => b[offset + i], 
			};
		}

		public GlbModel Lining(Func<float, float, float, bool> keep, float inset)
		{
			int[] array = new int[VertexCount];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = -1;
			}
			List<int> list = new List<int>();
			int num = 0;
			for (int j = 0; j < Triangles.Length; j += 3)
			{
				int num2 = Triangles[j];
				int num3 = Triangles[j + 1];
				int num4 = Triangles[j + 2];
				float arg = (Positions[num2 * 3] + Positions[num3 * 3] + Positions[num4 * 3]) / 3f;
				float arg2 = (Positions[num2 * 3 + 1] + Positions[num3 * 3 + 1] + Positions[num4 * 3 + 1]) / 3f;
				float arg3 = (Positions[num2 * 3 + 2] + Positions[num3 * 3 + 2] + Positions[num4 * 3 + 2]) / 3f;
				if (!keep(arg, arg2, arg3))
				{
					continue;
				}
				int[] array2 = new int[3] { num2, num4, num3 };
				foreach (int num5 in array2)
				{
					if (array[num5] < 0)
					{
						array[num5] = num++;
					}
					list.Add(array[num5]);
				}
			}
			GlbModel glbModel = new GlbModel
			{
				Positions = new float[num * 3],
				Normals = new float[num * 3],
				Uvs = ((Uvs != null) ? new float[num * 2] : null),
				Triangles = list.ToArray()
			};
			for (int l = 0; l < array.Length; l++)
			{
				int num6 = array[l];
				if (num6 >= 0)
				{
					float num7 = ((Normals != null) ? Normals[l * 3] : 0f);
					float num8 = ((Normals != null) ? Normals[l * 3 + 1] : 0f);
					float num9 = ((Normals != null) ? Normals[l * 3 + 2] : 0f);
					glbModel.Positions[num6 * 3] = Positions[l * 3] - num7 * inset;
					glbModel.Positions[num6 * 3 + 1] = Positions[l * 3 + 1] - num8 * inset;
					glbModel.Positions[num6 * 3 + 2] = Positions[l * 3 + 2] - num9 * inset;
					glbModel.Normals[num6 * 3] = 0f - num7;
					glbModel.Normals[num6 * 3 + 1] = 0f - num8;
					glbModel.Normals[num6 * 3 + 2] = 0f - num9;
					if (glbModel.Uvs != null)
					{
						glbModel.Uvs[num6 * 2] = Uvs[l * 2];
						glbModel.Uvs[num6 * 2 + 1] = Uvs[l * 2 + 1];
					}
				}
			}
			return glbModel;
		}
	}
	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;
		}

		private static string EnemyBarWidgets()
		{
			try
			{
				return (UiHPPool._NormalHp?.Count ?? (-1)).ToString();
			}
			catch
			{
				return "unavailable";
			}
		}

		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} enemyBarWidgets={EnemyBarWidgets()}");
				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(