Plugin.cs

using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Net.Sockets;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace OverlayHUD
{
    [BepInPlugin("local.overlay.overlay_hud", "OverlayHUD", "26.8.0")]
    public sealed class Plugin : BaseUnityPlugin, Photon.Realtime.IOnEventCallback
    {
        private static Plugin instance;
        private static readonly List<string> seenMonsters = new List<string>();
        private static readonly List<Component> knownEnemyParents = new List<Component>();
        private static readonly HashSet<int> sentEnemyInstanceIds = new HashSet<int>();
        private static readonly HashSet<int> valuablesInDollarHaul = new HashSet<int>();
        private static readonly object seenLock = new object();
        private static readonly object enemyLock = new object();
        private static readonly object reflectionCacheLock = new object();
        private static readonly object networkQueueLock = new object();

        private static readonly Dictionary<Type, Dictionary<string, MemberInfo>> fastMemberCache = new Dictionary<Type, Dictionary<string, MemberInfo>>();
        private static readonly Dictionary<Type, Dictionary<string, MethodInfo>> fastNoArgMethodCache = new Dictionary<Type, Dictionary<string, MethodInfo>>();

        private static Task networkQueueTail = Task.CompletedTask;
        private static int latestMonsterStatusRequestVersion;
        private static int latestMapValueRequestVersion;
        private static float mapValue, mapValueInitial, lostValue;

        private static readonly Dictionary<string, string> KnownMonsters = new Dictionary<string, string> { { "apexpredator", "Apex Predator" }, { "animal", "Animal" }, { "banger", "Banger" }, { "bang", "Banger" }, { "bella", "Bella" }, { "beamer", "Clown" }, { "birthdayboy", "Birthday Boy" }, { "bowtie", "Bowtie" }, { "chef", "Chef" }, { "cheffrog", "Chef" }, { "ceilingeye", "Peeper" }, { "cleanupcrew", "Cleanup Crew" }, { "clown", "Clown" }, { "clownbeamer", "Clown" }, { "duck", "Rugrat" }, { "elsa", "Elsa" }, { "floater", "Mentalist" }, { "gambit", "Gambit" }, { "gnome", "Gnomes" }, { "headgrab", "Headgrab" }, { "headgrabber", "Headgrab" }, { "headman", "Headman" }, { "hearthugger", "Heart Hugger" }, { "hidden", "Hidden" }, { "huntsman", "Huntsman" }, { "hunter", "Huntsman" }, { "loom", "Loom" }, { "mentalist", "Mentalist" }, { "oogly", "Oogly" }, { "peeper", "Peeper" }, { "reaper", "Reaper" }, { "robe", "Robe" }, { "rugrat", "Rugrat" }, { "runner", "Gambit" }, { "shadowchild", "Shadow Child" }, { "shadow", "Shadow Child" }, { "spewer", "Spewer" }, { "slowmouth", "Spewer" }, { "slowwalker", "Trudge" }, { "spinny", "Bowtie" }, { "thinman", "Reaper" }, { "tick", "Tick" }, { "trudge", "Trudge" }, { "tricycle", "Birthday Boy" }, { "tumbler", "Apex Predator" }, { "upscream", "Upscream" }, { "valuablethrower", "Rugrat" } };
        private static readonly KeyValuePair<string, string>[] TrackedPlayerUpgrades = { new KeyValuePair<string, string>("strength", "playerUpgradeStrength"), new KeyValuePair<string, string>("tumbleLaunch", "playerUpgradeLaunch"), new KeyValuePair<string, string>("range", "playerUpgradeRange"), new KeyValuePair<string, string>("sprintSpeed", "playerUpgradeSpeed"), new KeyValuePair<string, string>("tumbleWings", "playerUpgradeTumbleWings"), new KeyValuePair<string, string>("crouchRest", "playerUpgradeCrouchRest"), new KeyValuePair<string, string>("extraJump", "playerUpgradeExtraJump"), new KeyValuePair<string, string>("tumbleClimb", "playerUpgradeTumbleClimb"), new KeyValuePair<string, string>("health", "playerUpgradeHealth"), new KeyValuePair<string, string>("stamina", "playerUpgradeStamina"), new KeyValuePair<string, string>("mapPlayerCount", "playerUpgradeMapPlayerCount"), new KeyValuePair<string, string>("deathHeadBattery", "playerUpgradeDeathHeadBattery") };
        private static readonly Dictionary<string, string> UpgradeStateKeyByPunMethod = new Dictionary<string, string> { { "UpgradePlayerGrabStrength", "strength" }, { "UpgradePlayerTumbleLaunch", "tumbleLaunch" }, { "UpgradePlayerGrabRange", "range" }, { "UpgradePlayerSprintSpeed", "sprintSpeed" }, { "UpgradePlayerTumbleWings", "tumbleWings" }, { "UpgradePlayerCrouchRest", "crouchRest" }, { "UpgradePlayerExtraJump", "extraJump" }, { "UpgradePlayerTumbleClimb", "tumbleClimb" }, { "UpgradePlayerHealth", "health" }, { "UpgradePlayerEnergy", "stamina" }, { "UpgradeMapPlayerCount", "mapPlayerCount" }, { "UpgradeDeathHeadBattery", "deathHeadBattery" } };
        private static readonly HashSet<string> PlayerVisionLegacyFallbackMonsters = new HashSet<string>(StringComparer.Ordinal) { "Tick", "Upscream", "Headman", "Gnomes", "Gnome", "Rugrat", "Animal", "Oogly" };
        private static readonly string[] CurrentHealthMemberNames = { "currentHealth", "healthCurrent", "_currentSyncedHealth", "_syncedHealth", "currentHP", "healthValue", "HealthValue" };
        private static readonly string[] MaxHealthMemberNames = { "maxHealth", "MaxHealth", "healthMax", "HealthMax", "healthMaximum", "maximumHealth", "maxHP", "HPMax", "health", "Health" };

        private readonly Dictionary<string, float> lastSeenLoggedAt = new Dictionary<string, float>();
        private readonly Dictionary<int, string> resolvedMonsterNames = new Dictionary<int, string>();
        private readonly Dictionary<int, int> sourceIdsByEnemyParent = new Dictionary<int, int>();
        private readonly Dictionary<int, bool> lastAliveBySourceId = new Dictionary<int, bool>();
        private readonly Dictionary<int, string> lastHealthDebugBySourceId = new Dictionary<int, string>();
        private readonly Dictionary<int, object[]> healthSourcesByRootId = new Dictionary<int, object[]>();
        private readonly Dictionary<int, string> lastImmediateStatusBySourceId = new Dictionary<int, string>();
        private readonly Dictionary<int, string> lastTimerStatusBySourceId = new Dictionary<int, string>();
        private readonly Dictionary<int, float> lastTimerStatusSentAtBySourceId = new Dictionary<int, float>();
        private readonly Dictionary<int, bool> enemyHasVisionByParentId = new Dictionary<int, bool>();
        private readonly Dictionary<int, bool> enemyHasOnScreenByParentId = new Dictionary<int, bool>();
        private readonly Dictionary<int, VisionEnemyCache> visionEnemyCacheByVisionId = new Dictionary<int, VisionEnemyCache>();
        private readonly HashSet<int> pendingEncounterIds = new HashSet<int>();
        private readonly Dictionary<int, float> clientSimulatedTimers = new Dictionary<int, float>();
        private readonly Dictionary<int, float> clientSimulatedHealth = new Dictionary<int, float>();

        private readonly Dictionary<int, int> instanceIdByViewId = new Dictionary<int, int>();
        private readonly Dictionary<int, int> viewIdByInstanceId = new Dictionary<int, int>();
        private readonly Dictionary<int, float> lastTimerSyncSentAt = new Dictionary<int, float>();
        private readonly Dictionary<int, float> viewIdFailedInstanceIds = new Dictionary<int, float>();
        private readonly List<int> _timerKeysBuffer = new List<int>();

        private float nextScanAt, nextStatusSyncAt, nextUpgradeSyncAt, nextMapValueSyncAt, nextBroadEnemyDiscoveryAt, nextStatusDirectorRecoveryAt, scanPausedUntil, nextStatusHeartbeatAt;
        private int fallbackLevel = 1, lastSyncedLevel;
        private readonly Dictionary<string, int> lastSyncedUpgrades = new Dictionary<string, int>();
        private readonly HashSet<string> pendingUpgradeKeys = new HashSet<string>();
        private string lastRosterFingerprint = "", lastStatusFingerprint = "", pendingRosterFingerprint = "", pendingMapValueRefreshReason = "", lastMapValueFingerprint = "";
        private int rosterStableScans, broadEnemyDiscoveryAttempts;
        private bool rosterPublished, enemyRosterDirty, mapValueDirty, pendingMapValueRefresh;
        private int cachedLocalPlayerViewId = int.MinValue;
        private bool gameplayActive, wasCursorVisible = false, pendingCursorState = false, wasOverlayHidden = false;
        private float cursorStateChangeTime = 0f, focusLostTime = 0f;
        private Coroutine pendingGameplayActivation;
        private uint cachedOverlayPid = 0;
        private float nextOverlayPidCheck = 0f;
        private bool pendingBatchedStatusSync = false;
        private float nextBatchedStatusSyncAt = 0f;

        // Прямое кэширование для перехвата Photon

        [System.Runtime.InteropServices.DllImport("user32.dll")] private static extern IntPtr GetForegroundWindow();
        [System.Runtime.InteropServices.DllImport("user32.dll")] private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);

        private ConfigEntry<string> endpoint, levelEndpoint, overlayAppRelativePath, overlayAppArchiveName;
        private ConfigEntry<float> scanInterval, statusInterval;
        private ConfigEntry<bool> requireLineOfSight, preferPlayerVisionDetection, debugLogging, autoStartOverlayApp, autoCloseOverlayApp;
        private ConfigEntry<bool> enableNetworkSync;
        private Harmony harmony;
        private Process launchedOverlayProcess;

        private static readonly Dictionary<string, Type> typeCache = new Dictionary<string, Type>();
        private static Type GetTypeCached(string name)
        {
            if (typeCache.TryGetValue(name, out Type t)) return t;
            t = AccessTools.TypeByName(name);
            typeCache[name] = t;
            return t;
        }

        private void Awake()
        {
            instance = this;
            KeepPluginObjectAlive();
            endpoint = Config.Bind("Overlay", "Endpoint", "http://127.0.0.1:8787/api/monster-seen", "Monster endpoint");
            levelEndpoint = Config.Bind("Overlay", "LevelEndpoint", "http://127.0.0.1:8787/api/level", "Level sync endpoint");
            scanInterval = Config.Bind("Detection", "ScanIntervalSeconds", 6f, "");
            statusInterval = Config.Bind("Detection", "StatusIntervalSeconds", 15f, "");
            requireLineOfSight = Config.Bind("Detection", "RequireLineOfSight", true, "");
            preferPlayerVisionDetection = Config.Bind("Detection", "PreferPlayerVisionDetection", true, "");
            debugLogging = Config.Bind("Debug", "Logging", false, "");
            enableNetworkSync = Config.Bind("Network", "EnableNetworkSync", true, "Включить синхронизацию оверлея по сети (выключите при конфликтах)"); autoStartOverlayApp = Config.Bind("OverlayApp", "AutoStart", true, "");
            autoCloseOverlayApp = Config.Bind("OverlayApp", "AutoClose", true, "");
            overlayAppRelativePath = Config.Bind("OverlayApp", "ExecutableRelativePath", Path.Combine("OverlayHUD_app", "OverlayHUD.exe"), "");
            overlayAppArchiveName = Config.Bind("OverlayApp", "ArchiveName", "OverlayHUD_app.zip", "");

            Logger.LogInfo("OverlayHUD is running.");
            StartOverlayAppIfNeeded();
            PatchGameUpdates();
            try { Photon.Pun.PhotonNetwork.AddCallbackTarget(this); } catch { }
        }

        private void KeepPluginObjectAlive()
        {
            try { if (gameObject.transform.parent != null) gameObject.transform.parent = null; gameObject.hideFlags = HideFlags.HideAndDontSave; DontDestroyOnLoad(gameObject); } catch { }
        }

        private void StartOverlayAppIfNeeded()
        {
            if (!autoStartOverlayApp.Value) return;
            try
            {
                string exePath = ResolveOverlayAppPath();
                EnsureOverlayAppExtracted(exePath);
                if (string.IsNullOrWhiteSpace(exePath) || !File.Exists(exePath)) return;
                if (IsProcessAlreadyRunning(Path.GetFileNameWithoutExtension(exePath))) return;
                launchedOverlayProcess = Process.Start(new ProcessStartInfo { FileName = exePath, WorkingDirectory = Path.GetDirectoryName(exePath), UseShellExecute = true });
            }
            catch { }
        }

        private void StopOverlayAppIfNeeded()
        {
            if (!autoCloseOverlayApp.Value || launchedOverlayProcess == null) return;
            try { if (!launchedOverlayProcess.HasExited && !launchedOverlayProcess.CloseMainWindow() && !launchedOverlayProcess.WaitForExit(2500)) launchedOverlayProcess.Kill(); } catch { } finally { launchedOverlayProcess = null; }
        }

        private string ResolveOverlayAppPath() { string path = Assembly.GetExecutingAssembly().Location; return Path.GetFullPath(Path.Combine(string.IsNullOrWhiteSpace(path) ? Paths.PluginPath : Path.GetDirectoryName(path), overlayAppRelativePath.Value)); }
        private void EnsureOverlayAppExtracted(string exePath)
        {
            if (File.Exists(exePath)) return;
            string arcPath = Path.Combine(string.IsNullOrWhiteSpace(Assembly.GetExecutingAssembly().Location) ? Paths.PluginPath : Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), overlayAppArchiveName.Value);
            if (!File.Exists(arcPath)) return;
            try { string td = Path.GetDirectoryName(exePath); if (Directory.Exists(td)) Directory.Delete(td, true); Directory.CreateDirectory(td); ZipFile.ExtractToDirectory(arcPath, td); } catch { }
        }
        private static bool IsProcessAlreadyRunning(string proc) { try { return Process.GetProcessesByName(proc).Length > 0; } catch { return false; } }
        private bool IsOverlayFocused()
        {
            try
            {
                IntPtr fg = GetForegroundWindow(); if (fg == IntPtr.Zero) return false;
                GetWindowThreadProcessId(fg, out uint pid);
                if (launchedOverlayProcess != null && !launchedOverlayProcess.HasExited && pid == (uint)launchedOverlayProcess.Id) return true;
                if (pid == cachedOverlayPid) return true;
                if (Time.unscaledTime > nextOverlayPidCheck)
                {
                    nextOverlayPidCheck = Time.unscaledTime + 2f;
                    using (Process p = Process.GetProcessById((int)pid)) { if (p.ProcessName.IndexOf("overlay", StringComparison.OrdinalIgnoreCase) >= 0) { cachedOverlayPid = pid; return true; } }
                }
            }
            catch { }
            return false;
        }

        private void PatchGameUpdates()
        {
            try
            {
                harmony = new Harmony("local.overlay.overlay_hud");
                MethodInfo m1 = AccessTools.Method("EnemyParent:SpawnRPC"), m2 = AccessTools.Method("EnemyParent:DespawnRPC"), m3 = AccessTools.Method("EnemyParent:DisableDecrease"), m4 = AccessTools.Method("EnemyParent:DespawnedTimerSet"), m5 = AccessTools.Method("EnemyParent:PlayerCloseLogic"), m6 = AccessTools.Method("EnemyOnScreen:Logic"), m7 = AccessTools.Method("LevelGenerator:StartRoomGeneration"), m8 = AccessTools.Method("RunManager:ChangeLevel"), m9 = AccessTools.Method("RoundDirector:ExtractionCompleted"), m10 = AccessTools.Method("ValuableObject:DollarValueSetRPC"), m11 = AccessTools.Method("ValuableObject:DollarValueSetLogic"), m12 = AccessTools.Method("ValuableObject:AddToDollarHaulList"), m13 = AccessTools.Method("ValuableObject:AddToDollarHaulListRPC"), m14 = AccessTools.Method("ValuableObject:RemoveFromDollarHaulList"), m15 = AccessTools.Method("ValuableObject:RemoveFromDollarHaulListRPC"), m16 = AccessTools.Method("PhysGrabObjectImpactDetector:BreakRPC"), m17 = AccessTools.Method("PhysGrabObject:DestroyPhysGrabObjectRPC"), m18 = AccessTools.Method("EnemyVision:VisionTrigger"), m19 = AccessTools.Method("EnemyHealth:Hurt"), m20 = AccessTools.Method("EnemyHealth:HurtRPC");
                if (m1 != null) harmony.Patch(m1, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(EnemyParentSpawnedPostfix))));
                if (m2 != null) harmony.Patch(m2, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(EnemyParentDespawnedPostfix))));
                if (m3 != null) harmony.Patch(m3, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(EnemyParentTimerChangedPostfix))));
                if (m4 != null) harmony.Patch(m4, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(EnemyParentTimerChangedPostfix))));
                if (m5 != null) harmony.Patch(m5, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(EnemyParentPlayerCloseLogicPostfix))));
                if (m6 != null) harmony.Patch(m6, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(EnemyOnScreenLogicPostfix))));
                if (m7 != null) harmony.Patch(m7, prefix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(LevelGenerationStartingPrefix))));
                if (m8 != null) harmony.Patch(m8, prefix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(LevelChangingPrefix))), postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(LevelChangedPostfix))));
                if (m9 != null) harmony.Patch(m9, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(ExtractionCompletedPostfix))));
                if (m10 != null) harmony.Patch(m10, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(ValuableDollarValueSetRpcPostfix))));
                if (m11 != null) harmony.Patch(m11, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(ValuableDollarValueSetLogicPostfix))));
                if (m12 != null) harmony.Patch(m12, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(ValuableDollarHaulAddPostfix))));
                if (m13 != null) harmony.Patch(m13, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(ValuableDollarHaulAddPostfix))));
                if (m14 != null) harmony.Patch(m14, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(ValuableDollarHaulRemovePostfix))));
                if (m15 != null) harmony.Patch(m15, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(ValuableDollarHaulRemovePostfix))));
                if (m16 != null) harmony.Patch(m16, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(PhysGrabObjectBreakPostfix))));
                if (m17 != null) harmony.Patch(m17, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(PhysGrabObjectDestroyedPostfix))));
                if (m18 != null) harmony.Patch(m18, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(EnemyVisionTriggerPostfix))));
                if (m19 != null) harmony.Patch(m19, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(EnemyHealthChangedPostfix))));
                if (m20 != null) harmony.Patch(m20, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(EnemyHealthHurtRpcPostfix))));
                foreach (string mName in UpgradeStateKeyByPunMethod.Keys) { MethodInfo m = AccessTools.Method("PunManager:" + mName); if (m != null) harmony.Patch(m, postfix: new HarmonyMethod(AccessTools.Method(typeof(Plugin), nameof(PlayerUpgradeAppliedPostfix)))); }
            }

            catch { }
            SceneManager.sceneLoaded += OnSceneLoaded;
        }

        private static void LevelGenerationStartingPrefix() { try { instance?.ResetMapValue("room generation started"); } catch { } }
        private static void LevelChangingPrefix() { try { instance?.HandleLevelChanging(); } catch { } }
        private static void LevelChangedPostfix(object __instance) { try { instance?.ScheduleGameplayActivation("RunManager.ChangeLevel"); } catch { } }
        private static void PlayerUpgradeAppliedPostfix(MethodBase __originalMethod, string _steamID, int __result) { try { if (__originalMethod != null && UpgradeStateKeyByPunMethod.TryGetValue(__originalMethod.Name, out string k)) instance?.SyncPlayerUpgradeValue(k, _steamID, __result); } catch { } }
        private void SyncPlayerUpgradeValue(string stateKey, string steamId, int value) { try { if (gameplayActive && !string.IsNullOrEmpty(stateKey) && !string.IsNullOrEmpty(steamId)) SyncPlayerUpgradesIfChanged(null); } catch { } }
        private static void EnemyParentSpawnedPostfix(object __instance) { try { if (__instance is Component comp) { RegisterEnemyParent(comp); if (instance != null) { GameObject root = GetEnemyRoot(comp); if (root != null) { var cand = new EnemyCandidate { Component = comp, Root = root, Center = Vector3.zero }; instance.clientSimulatedHealth.Remove(instance.GetStableEnemyId(cand)); } } instance?.SyncEnemyParentStatusChanged(comp); } } catch { } }
        private static void EnemyParentDespawnedPostfix(object __instance) { try { if (__instance is Component comp) instance?.ScheduleEnemyParentStatusChanged(comp); } catch { } }
        private static void EnemyParentTimerChangedPostfix(object __instance) { try { if (__instance is Component comp) instance?.SyncEnemyParentTimerChanged(comp); } catch { } }
        private static void EnemyParentPlayerCloseLogicPostfix(object __instance, ref IEnumerator __result) { try { if (__result != null && __instance is Component ep) __result = WatchBlindEnemyPlayerClose(__result, ep); } catch { } }
        private static void EnemyOnScreenLogicPostfix(object __instance, ref IEnumerator __result) { try { if (__result != null && __instance is Component eos) __result = WatchEnemyOnScreen(__result, eos); } catch { } }
        // Оптимизировано: проверка идет не каждый кадр, а только каждый 5-й, чтобы снять нагрузку с ЦП
        private static IEnumerator WatchBlindEnemyPlayerClose(IEnumerator inner, Component enemyParent)
        {
            bool wasPlayerClose = IsEnemyParentPlayerClose(enemyParent);
            bool wasPlayerVeryClose = instance != null && IsEnemyParentPlayerVeryClose(enemyParent);
            int frameThrottle = 0;
            while (inner.MoveNext())
            {
                yield return inner.Current;
                if (++frameThrottle < 5) continue;
                frameThrottle = 0;

                Plugin plugin = instance;
                if (plugin == null || !plugin.gameplayActive || enemyParent == null) continue;
                bool isPlayerClose = IsEnemyParentPlayerClose(enemyParent);
                bool isPlayerVeryClose = IsEnemyParentPlayerVeryClose(enemyParent);
                if (isPlayerClose != wasPlayerClose || isPlayerVeryClose != wasPlayerVeryClose) plugin.SyncEnemyParentStatusChanged(enemyParent);
                if (isPlayerVeryClose && !wasPlayerVeryClose && (!plugin.preferPlayerVisionDetection.Value || !HasEnemyOnScreen(enemyParent) || ShouldUseLegacyVisionFallback(enemyParent))) plugin.HandleBlindEnemyPlayerVeryClose(enemyParent);
                wasPlayerClose = isPlayerClose; wasPlayerVeryClose = isPlayerVeryClose;
            }
        }

        // Оптимизировано: проверка идет каждый 5-й кадр
        private static IEnumerator WatchEnemyOnScreen(IEnumerator inner, Component enemyOnScreen)
        {
            Component enemyParent = null; int stableId = 0; bool encounterHandled = false;
            int frameThrottle = 0;
            while (inner.MoveNext())
            {
                yield return inner.Current;
                if (++frameThrottle < 5) continue;
                frameThrottle = 0;

                Plugin plugin = instance;
                if (plugin == null || !plugin.gameplayActive || enemyOnScreen == null || encounterHandled || !plugin.preferPlayerVisionDetection.Value) continue;
                if (enemyParent == null) enemyParent = GetEnemyParentFromOnScreen(enemyOnScreen);
                if (enemyParent == null) continue;
                if (stableId == 0) stableId = plugin.GetStableEnemyId(new EnemyCandidate { Component = enemyParent, Root = GetEnemyRoot(enemyParent) });
                if (stableId != 0 && IsEnemySent(stableId)) { encounterHandled = true; continue; }
                if (!plugin.IsEnemyOnScreenVisible(enemyOnScreen)) continue;
                plugin.HandleEnemyOnScreenVisible(enemyParent, ref stableId);
                if (stableId != 0 && IsEnemySent(stableId)) encounterHandled = true;
            }
        }

        private static void ExtractionCompletedPostfix() { try { instance?.RefreshMapValue("extraction completed"); } catch { } }
        private static void ValuableDollarValueSetRpcPostfix(object __instance, float value) { try { instance?.ScheduleMapValueRefresh("valuable rpc"); } catch { } }
        private static void ValuableDollarValueSetLogicPostfix(object __instance) { try { if (CachedIsMasterClient()) instance?.ScheduleMapValueRefresh("valuable logic"); } catch { } }
        private static void ValuableDollarHaulAddPostfix(object __instance) { try { TrackDollarHaulValuable(__instance, true); } catch { } }
        private static void ValuableDollarHaulRemovePostfix(object __instance) { try { TrackDollarHaulValuable(__instance, false); } catch { } }
        private static void PhysGrabObjectBreakPostfix(object __instance, float valueLost, bool _loseValue) { try { if (_loseValue) { instance?.AddMapValue(-valueLost, "valuable break"); instance?.AddLostValue(valueLost, "valuable break"); } } catch { } }
        private static void PhysGrabObjectDestroyedPostfix(object __instance) { try { if (!CachedIsRunLevel(null)) return; Component val = GetValuableComponent(__instance); if (val == null) return; float cur = ReadValuableCurrentValue(val), orig = ReadValuableOriginalValue(val); if (orig > 0f && cur < orig * 0.15f) return; instance?.AddMapValue(-cur, "valuable destroyed"); if (!IsValuableInDollarHaul(val)) instance?.AddLostValue(cur, "valuable destroyed"); } catch { } }
        private static void EnemyVisionTriggerPostfix(object __instance, int playerID, object player, bool culled, bool playerNear) { try { instance?.HandleEnemyVisionTrigger(__instance, playerID); } catch { } }

        private static void EnemyHealthChangedPostfix(object __instance) { try { instance?.SyncEnemyHealthChanged(__instance); } catch { } }
        private static void EnemyHealthHurtRpcPostfix(object __instance, object[] __args)
        {
            try
            {
                if (instance == null || !instance.gameplayActive || __instance == null || __args == null || __args.Length == 0) return;
                float dmg = 0f; if (__args[0] != null) TryConvertFloat(__args[0], out dmg);
                Component ep = ReadMember(ReadMember(__instance, "enemy") as Component ?? __instance, "EnemyParent") as Component;
                if (ep != null && dmg > 0f)
                {
                    GameObject root = GetEnemyRoot(ep);
                    if (root != null)
                    {
                        var cand = new EnemyCandidate { Component = ep, Root = root, Center = Vector3.zero };
                        int stableId = instance.GetStableEnemyId(cand);
                        if (!instance.clientSimulatedHealth.ContainsKey(stableId) && instance.TryGetEnemyHealth(cand, out float h, out float mh)) instance.clientSimulatedHealth[stableId] = h;
                        if (instance.clientSimulatedHealth.ContainsKey(stableId)) instance.clientSimulatedHealth[stableId] = Math.Max(0f, instance.clientSimulatedHealth[stableId] - dmg);
                    }
                    instance.SyncEnemyParentStatusChanged(ep);
                }
            }
            catch { }
        }

        private static Type photonNetworkType, raiseEventOptionsType, sendOptionsType;
        private static MethodInfo raiseEventMethod;
        private static object raiseEventOptionsOthers, sendReliableOptions;

        private static void InitPhotonReflection()
        {
            try
            {
                if (photonNetworkType == null)
                {
                    photonNetworkType = GetTypeCached("Photon.Pun.PhotonNetwork");
                    raiseEventOptionsType = GetTypeCached("Photon.Realtime.RaiseEventOptions");
                    sendOptionsType = GetTypeCached("ExitGames.Client.Photon.SendOptions");
                    if (photonNetworkType != null && raiseEventOptionsType != null && sendOptionsType != null)
                    {
                        raiseEventOptionsOthers = Activator.CreateInstance(raiseEventOptionsType);
                        var rf = raiseEventOptionsType.GetField("Receivers");
                        if (rf != null) rf.SetValue(raiseEventOptionsOthers, Enum.ToObject(rf.FieldType, 1));
                        sendReliableOptions = sendOptionsType.GetField("SendReliable", BindingFlags.Public | BindingFlags.Static)?.GetValue(null) ?? sendOptionsType.GetProperty("SendReliable", BindingFlags.Public | BindingFlags.Static)?.GetValue(null, null);
                        raiseEventMethod = AccessTools.Method(photonNetworkType, "RaiseEvent", new Type[] { typeof(byte), typeof(object), raiseEventOptionsType, sendOptionsType });
                    }
                }
            }
            catch { }
        }

        private static void SendOverlayEvent(object[] data)
        {
            if (instance == null || !instance.enableNetworkSync.Value) return;
            if (raiseEventMethod == null) InitPhotonReflection();
            if (raiseEventMethod != null) { try { raiseEventMethod.Invoke(null, new object[] { (byte)187, data, raiseEventOptionsOthers, sendReliableOptions }); } catch { } }
        }

        public void OnEvent(ExitGames.Client.Photon.EventData photonEvent)
        {
            if (instance == null || !instance.enableNetworkSync.Value) return;
            if (!gameplayActive || photonEvent.Code != 187) return;

            if (photonEvent.CustomData is object[] data && data.Length >= 3)
            {
                string action = data[0] as string;
                int viewId = Convert.ToInt32(data[1]);
                if (action == "SPOT") HandleRemoteSpot(viewId, data[2] as string);
                else if (action == "TIMER") HandleRemoteTimer(viewId, Convert.ToSingle(data[2], CultureInfo.InvariantCulture));
            }
        }

        private int GetStableEnemyId(EnemyCandidate candidate)
        {
            if (candidate.Root == null) return 0;
            int iId = candidate.Root.GetInstanceID();
            Component ep = GetEnemyParent(candidate);
            if (ep != null)
            {
                int viewId = GetEnemyViewId(ep, iId);
                if (viewId != 0) return -Math.Abs(viewId);
            }
            return iId;
        }

        private void HandleRemoteSpot(int viewId, string monsterName)
        {
            if (!gameplayActive) return;
            int stableId = -Math.Abs(viewId);
            if (IsEnemySent(stableId) || pendingEncounterIds.Contains(stableId)) return;
            if (!TryMarkEnemySent(stableId)) return;
            MarkMonsterSeen(monsterName, default(EnemyCandidate));
            if (gameObject.activeInHierarchy) StartCoroutine(PostSeenMonster(monsterName, stableId));
        }

        private void HandleRemoteTimer(int viewId, float timer)
        {
            if (!gameplayActive) return;
            int stableId = -Math.Abs(viewId);
            clientSimulatedTimers[stableId] = timer;
        }

        private int GetEnemyViewId(Component ep, int iId)
        {
            if (viewIdByInstanceId.TryGetValue(iId, out int viewId)) return viewId;

            // Если проверяли меньше 2 секунд назад - пропускаем (TTL)
            if (viewIdFailedInstanceIds.TryGetValue(iId, out float failedAt) && Time.realtimeSinceStartup - failedAt < 2f)
                return 0;

            object photonView = ReadMember(ep, "photonView");
            if (photonView == null) { Component enemy = ReadMember(ep, "Enemy") as Component; if (enemy != null) photonView = ReadMember(enemy, "photonView"); }
            if (photonView != null)
            {
                viewId = ReadIntMember(photonView, "ViewID");
                if (viewId != 0)
                {
                    viewIdByInstanceId[iId] = viewId;
                    instanceIdByViewId[viewId] = iId;
                    viewIdFailedInstanceIds.Remove(iId); // Успех - убираем из черного списка
                    return viewId;
                }
            }
            viewIdFailedInstanceIds[iId] = Time.realtimeSinceStartup; // Обновляем время неудачи
            return 0;
        }

        // --- UPDATE & CORE LOGIC ---
        private void Update()
        {
            if (!gameplayActive) { if (pendingGameplayActivation == null && CachedIsRunLevel(SceneManager.GetActiveScene().name)) ScheduleGameplayActivation("Client update fallback"); return; }
            bool isGameFocused = Application.isFocused, isSafeFocused = isGameFocused || IsOverlayFocused();
            if (isSafeFocused) { focusLostTime = 0f; if (wasOverlayHidden) { wasOverlayHidden = false; if (gameObject.activeInHierarchy) StartCoroutine(PostTabHidden(false)); } }
            else { focusLostTime += Time.unscaledDeltaTime; if (focusLostTime > 0.5f && !wasOverlayHidden) { wasOverlayHidden = true; if (gameObject.activeInHierarchy) StartCoroutine(PostTabHidden(true)); } }
            bool isCursorVisible = Cursor.visible;
            if (isCursorVisible != pendingCursorState) { pendingCursorState = isCursorVisible; cursorStateChangeTime = Time.unscaledTime + 0.3f; }
            if (pendingCursorState != wasCursorVisible && Time.unscaledTime >= cursorStateChangeTime) { wasCursorVisible = pendingCursorState; if (gameObject.activeInHierarchy) StartCoroutine(PostCursorState(wasCursorVisible)); }

            TickScan();
        }

        private void TickScan()
        {
            if (!gameplayActive) return; float now = Time.realtimeSinceStartup;
            if (mapValueDirty && now >= nextMapValueSyncAt) SyncMapValueIfChanged();

            if (now >= nextStatusHeartbeatAt)
            {
                nextStatusHeartbeatAt = now + 2f;
                pendingBatchedStatusSync = true;
            }

            if (pendingBatchedStatusSync && now >= nextBatchedStatusSyncAt)
            {
                nextBatchedStatusSyncAt = now + 0.2f;
                pendingBatchedStatusSync = false;
                SyncMonsterStatuses(new List<ResolvedEnemyCandidate>());
            }

            if (now < scanPausedUntil) return;
            if (pendingUpgradeKeys.Count > 0 && now >= nextUpgradeSyncAt) { var keys = new HashSet<string>(pendingUpgradeKeys); pendingUpgradeKeys.Clear(); SyncPlayerUpgradesIfChanged(keys); }
            if (rosterPublished && now >= nextStatusSyncAt) { nextStatusSyncAt = now + Math.Max(10f, statusInterval.Value); pendingBatchedStatusSync = true; }
            if (!enemyRosterDirty || now < nextScanAt) return;
            nextScanAt = now + Math.Max(0.05f, scanInterval.Value);
            try { SyncKnownEnemies(); } catch { }
        }

        private void OnDestroy()
        {
            try { Photon.Pun.PhotonNetwork.RemoveCallbackTarget(this); } catch { }
            SceneManager.sceneLoaded -= OnSceneLoaded;
            harmony?.UnpatchSelf();
            if (gameplayActive) HandleLevelChanging();
            StopOverlayAppIfNeeded();
            if (instance == this) instance = null;
        }
        private void OnSceneLoaded(Scene scene, LoadSceneMode mode) { if (gameplayActive && !CachedIsRunLevel(scene.name)) HandleLevelChanging(); else if (!gameplayActive && CachedIsRunLevel(scene.name)) ScheduleGameplayActivation("Scene loaded"); }
        private void ScheduleGameplayActivation(string reason) { if (pendingGameplayActivation != null) StopCoroutine(pendingGameplayActivation); if (gameObject.activeInHierarchy) pendingGameplayActivation = StartCoroutine(ActivateGameplayAfterLevelChange(reason)); }
        private IEnumerator ActivateGameplayAfterLevelChange(string reason)
        {
            for (int i = 1; i <= 40; i++) { yield return new WaitForSecondsRealtime(0.25f); if (IsGameplayLevelCandidate(out _)) { yield return new WaitForSecondsRealtime(5f); HandleGameplayDetected(reason); pendingGameplayActivation = null; yield break; } if (IsNonGameplayContext() && i > 5) break; }
            pendingGameplayActivation = null;
        }

        private bool HandleGameplayDetected(string reason)
        {
            if (gameplayActive) return true; ResetSeenMonsters("new level"); mapValue = 0f; mapValueInitial = 0f; lostValue = 0f; valuablesInDollarHaul.Clear(); lastMapValueFingerprint = ""; gameplayActive = true;
            int lvl = ResolveCurrentLevel(); if (lvl > 0) SyncLevelToOverlay(lvl, ResolveCurrentLevelName()); return true;
        }

        private void HandleLevelChanging() { if (!gameplayActive) return; gameplayActive = false; SyncMapValueIfChanged(); ResetMapValue("level changing"); if (gameObject.activeInHierarchy) StartCoroutine(PostVisibility(false)); }
        private void ResetMapValue(string reason) { mapValue = 0f; mapValueInitial = 0f; lostValue = 0f; valuablesInDollarHaul.Clear(); lastMapValueFingerprint = ""; mapValueDirty = false; pendingMapValueRefresh = false; pendingMapValueRefreshReason = ""; }
        private void RefreshMapValue(string reason) { if (CachedIsRunLevel(null)) { mapValue = CalculateMapValue(); MarkMapValueDirty(); } }
        private void ScheduleMapValueRefresh(string reason) { if (CachedIsRunLevel(null)) { pendingMapValueRefresh = true; pendingMapValueRefreshReason = reason; MarkMapValueDirty(); } }
        private void AddMapValue(float delta, string reason) { if (CachedIsRunLevel(null) && !float.IsNaN(delta) && Math.Abs(delta) >= 0.01f) { mapValue = Math.Max(0f, mapValue + delta); MarkMapValueDirty(); } }
        private void AddLostValue(float value, string reason) { if (CachedIsRunLevel(null) && !float.IsNaN(value) && value >= 0.01f) { lostValue += value; MarkMapValueDirty(); } }
        private void MarkMapValueDirty() { mapValueDirty = true; nextMapValueSyncAt = Time.realtimeSinceStartup + 1.0f; }

        private void SyncMapValueIfChanged()
        {
            mapValueDirty = false; if (pendingMapValueRefresh) { pendingMapValueRefresh = false; mapValue = CalculateMapValue(); if (mapValueInitial <= 0f && mapValue > 0f) mapValueInitial = mapValue; pendingMapValueRefreshReason = ""; }
            int val = Math.Max(0, (int)Math.Round(mapValue)), init = Math.Max(0, (int)Math.Round(mapValueInitial)), lost = Math.Max(0, (int)Math.Round(lostValue)); int? goal = ResolveExtractionGoal();
            string fp = val + ":" + init + ":" + lost + ":" + (goal.HasValue ? goal.Value.ToString() : ""); if (fp == lastMapValueFingerprint) return; lastMapValueFingerprint = fp;
            if (gameObject.activeInHierarchy) StartCoroutine(PostMapValue(val, init, lost, goal));
        }

        private void ResetSeenMonsters(string reason)
        {
            lock (seenLock) { seenMonsters.Clear(); }
            lock (enemyLock) { knownEnemyParents.Clear(); sentEnemyInstanceIds.Clear(); }
            lastSeenLoggedAt.Clear(); resolvedMonsterNames.Clear(); sourceIdsByEnemyParent.Clear(); lastAliveBySourceId.Clear(); lastHealthDebugBySourceId.Clear(); healthSourcesByRootId.Clear();
            lastImmediateStatusBySourceId.Clear(); lastTimerStatusBySourceId.Clear(); lastTimerStatusSentAtBySourceId.Clear(); enemyHasVisionByParentId.Clear(); enemyHasOnScreenByParentId.Clear();
            visionEnemyCacheByVisionId.Clear(); pendingEncounterIds.Clear(); cachedLocalPlayerViewId = int.MinValue;
            lastRosterFingerprint = ""; lastStatusFingerprint = ""; pendingRosterFingerprint = ""; rosterStableScans = 0; broadEnemyDiscoveryAttempts = 0; rosterPublished = false; enemyRosterDirty = true;
            scanPausedUntil = Time.realtimeSinceStartup + 2f; nextScanAt = scanPausedUntil; nextStatusSyncAt = scanPausedUntil; nextUpgradeSyncAt = scanPausedUntil; nextBroadEnemyDiscoveryAt = scanPausedUntil; nextStatusDirectorRecoveryAt = scanPausedUntil;
            clientSimulatedTimers.Clear(); clientSimulatedHealth.Clear(); instanceIdByViewId.Clear(); viewIdByInstanceId.Clear(); lastTimerSyncSentAt.Clear(); viewIdFailedInstanceIds.Clear();
            pendingBatchedStatusSync = false; nextBatchedStatusSyncAt = 0f;
        }

        private void SyncKnownEnemies()
        {
            List<EnemyCandidate> found = FindEnemyCandidates(); var res = new List<ResolvedEnemyCandidate>();
            foreach (EnemyCandidate cand in found) { int stableId = GetStableEnemyId(cand); if (!resolvedMonsterNames.TryGetValue(stableId, out string mName)) { mName = ResolveMonsterName(cand.Component); if (mName != null) resolvedMonsterNames[stableId] = mName; } if (mName != null) res.Add(new ResolvedEnemyCandidate { Candidate = cand, MonsterName = mName }); }
            if (!SyncMonsterRoster(res)) return;
            if (!requireLineOfSight.Value) RevealAllKnownEnemies(res);
            if (res.Count == 0) { enemyRosterDirty = false; return; }
            SyncMonsterStatuses(res); TryPublishPendingVisionEncounters(res); enemyRosterDirty = false;
        }

        private void RevealAllKnownEnemies(List<ResolvedEnemyCandidate> enemies) { foreach (var res in enemies) { int stableId = GetStableEnemyId(res.Candidate); if (!TryMarkEnemySent(stableId)) continue; pendingEncounterIds.Remove(stableId); MarkMonsterSeen(res.MonsterName, res.Candidate); if (gameObject.activeInHierarchy) StartCoroutine(PostSeenMonster(res.MonsterName, stableId)); } }

        private bool SyncMonsterRoster(List<ResolvedEnemyCandidate> enemies)
        {
            enemies.Sort((l, r) => GetStableEnemyId(l.Candidate).CompareTo(GetStableEnemyId(r.Candidate)));
            var fp = new StringBuilder(); foreach (var e in enemies) fp.Append(GetStableEnemyId(e.Candidate)).Append(':').Append(e.MonsterName).Append(';'); string nextFp = fp.ToString();
            if (!rosterPublished) { if (nextFp != pendingRosterFingerprint) { pendingRosterFingerprint = nextFp; rosterStableScans = 0; return false; } if (++rosterStableScans < 2) return false; rosterPublished = true; }
            if (nextFp == lastRosterFingerprint) return true; lastRosterFingerprint = nextFp;
            var json = new StringBuilder("{\"monsters\":["); for (int i = 0; i < enemies.Count; i++) { if (i > 0) json.Append(','); json.Append("{\"id\":").Append(GetStableEnemyId(enemies[i].Candidate)).Append(",\"name\":\"").Append(EscapeJson(enemies[i].MonsterName)).Append("\"}"); }
            json.Append("]}");
            if (gameObject.activeInHierarchy) StartCoroutine(PostMonsterRoster(json.ToString())); return true;
        }

        // Оптимизировано: умное округление таймера в Fingerprint избавляет от спама HTTP запросами
        private void SyncMonsterStatuses(List<ResolvedEnemyCandidate> enemies)
        {
            var json = new StringBuilder("{\"statuses\":["); var fp = new StringBuilder(); int statusCount = 0; var cands = new Dictionary<int, EnemyCandidate>();
            foreach (var e in enemies) { int sId = GetStableEnemyId(e.Candidate); cands[sId] = e.Candidate; Component p = GetEnemyParent(e.Candidate); if (p != null) sourceIdsByEnemyParent[p.GetInstanceID()] = sId; }
            foreach (Component p in GetKnownEnemyParentsSnapshot()) if (p != null) AddStatusCandidate(cands, p);
            float now = Time.realtimeSinceStartup;
            if (cands.Count == 0 || now >= nextStatusDirectorRecoveryAt) { nextStatusDirectorRecoveryAt = now + 30f; foreach (Component p in FindSpawnedEnemiesFromDirector()) if (p != null) { RegisterEnemyParent(p); AddStatusCandidate(cands, p); } }
            var keys = new List<int>(cands.Keys); keys.Sort();
            foreach (int stableId in keys)
            {
                EnemyCandidate cand = cands[stableId]; if (!TryGetEnemyRespawnStatus(cand, out bool alive, out float rem)) continue;
                float h = 0f, mh = 0f; bool ih = IsEnemySent(stableId); bool hasHealth = ih && TryGetEnemyHealth(cand, out h, out mh);
                Component sep = GetEnemyParent(cand); bool pc = IsEnemyParentPlayerClose(sep), pvc = IsEnemyParentPlayerVeryClose(sep); lastAliveBySourceId[stableId] = alive;
                float rr = alive ? 0f : (float)Math.Ceiling(Math.Max(0f, rem) * 10f) / 10f;
                string rt = rr.ToString("0.0", CultureInfo.InvariantCulture), ht = hasHealth ? Math.Max(0f, h).ToString("0.#", CultureInfo.InvariantCulture) : "", mht = hasHealth && mh > 0f ? mh.ToString("0.#", CultureInfo.InvariantCulture) : "";

                int fpTimer = alive ? 0 : (int)Math.Round(rem);
                fp.Append(stableId).Append(':').Append(alive ? '1' : '0').Append(':').Append(fpTimer).Append(':').Append(ht).Append('/').Append(mht).Append(':').Append(pc ? '1' : '0').Append(':').Append(pvc ? '1' : '0').Append(';');

                if (statusCount++ > 0) json.Append(',');
                json.Append("{\"id\":").Append(stableId).Append(",\"alive\":").Append(alive ? "true" : "false").Append(",\"respawnRemaining\":").Append(rt).Append(",\"playerClose\":").Append(pc ? "true" : "false").Append(",\"playerVeryClose\":").Append(pvc ? "true" : "false");
                if (hasHealth) { json.Append(",\"health\":").Append(ht.Length > 0 ? ht : "0"); if (mht.Length > 0) json.Append(",\"maxHealth\":").Append(mht); }
                json.Append('}');
            }
            if (statusCount == 0) return; string nFp = fp.ToString(); if (nFp == lastStatusFingerprint) return; lastStatusFingerprint = nFp; json.Append("]}");
            if (gameObject.activeInHierarchy) StartCoroutine(PostMonsterStatuses(json.ToString(), true));
        }

        private static bool TryGetEnemyRespawnStatus(EnemyCandidate candidate, out bool alive, out float remaining)
        {
            alive = true; remaining = 0f; Component p = GetEnemyParent(candidate); if (p == null) return false;
            alive = ReadEnemySpawned(p); TryConvertFloat(ReadMember(p, "DespawnedTimer"), out float realTimer);
            if (instance != null && candidate.Root != null)
            {
                int stableId = instance.GetStableEnemyId(candidate);
                if (!alive)
                {
                    if (CachedIsMasterClient())
                    {
                        remaining = realTimer;
                        bool justDied = instance.lastAliveBySourceId.TryGetValue(stableId, out bool wasAlive) && wasAlive;
                        if (realTimer > 0f && (justDied || !instance.lastTimerSyncSentAt.TryGetValue(stableId, out float lastSent) || Time.realtimeSinceStartup - lastSent > 4f))
                        {
                            int viewId = instance.GetEnemyViewId(p, candidate.Root.GetInstanceID());
                            if (viewId != 0) { SendOverlayEvent(new object[] { "TIMER", viewId, realTimer }); instance.lastTimerSyncSentAt[stableId] = Time.realtimeSinceStartup; }
                        }
                        instance.clientSimulatedTimers[stableId] = remaining;
                    }
                    else
                    {
                        if (!instance.clientSimulatedTimers.TryGetValue(stableId, out float sim) || (realTimer > 0f && Math.Abs(realTimer - sim) > 1.5f)) instance.clientSimulatedTimers[stableId] = realTimer;
                        remaining = instance.clientSimulatedTimers[stableId];
                    }
                }
                else instance.clientSimulatedTimers[stableId] = 0f;
            }
            return true;
        }

        private void AddStatusCandidate(Dictionary<int, EnemyCandidate> statusCandidates, Component enemyParent) { GameObject root = GetEnemyRoot(enemyParent); int pId = enemyParent.GetInstanceID(); if (root != null) { var cand = new EnemyCandidate { Component = enemyParent, Root = root, Center = Vector3.zero }; int sId = GetStableEnemyId(cand); sourceIdsByEnemyParent[pId] = sId; statusCandidates[sId] = cand; } else if (!sourceIdsByEnemyParent.TryGetValue(pId, out int sId)) return; }
        private void SyncEnemyHealthChanged(object enemyHealthSource) { if (!gameplayActive || enemyHealthSource == null) return; Component enemyParent = ReadMember(ReadMember(enemyHealthSource, "enemy") as Component, "EnemyParent") as Component; SyncEnemyParentStatusChanged(enemyParent); }
        private void ScheduleEnemyParentStatusChanged(Component enemyParent) { if (gameplayActive && enemyParent != null && gameObject.activeInHierarchy) StartCoroutine(SyncEnemyParentStatusChangedNextFrame(enemyParent)); }
        private IEnumerator SyncEnemyParentStatusChangedNextFrame(Component enemyParent) { for (int i = 0; i < 6; i++) { yield return new WaitForSecondsRealtime(0.2f); SyncEnemyParentStatusChanged(enemyParent); } }
        private void SyncEnemyParentTimerChanged(Component enemyParent) { if (!gameplayActive || enemyParent == null) return; pendingBatchedStatusSync = true; }
        private void SyncEnemyParentStatusChanged(Component enemyParent) { if (!gameplayActive || enemyParent == null) return; pendingBatchedStatusSync = true; }

        private static bool ReadEnemySpawned(Component enemyParent) { object sv = ReadMember(enemyParent, "Spawned"); return sv is bool b ? b : (enemyParent.gameObject != null && enemyParent.gameObject.activeInHierarchy); }
        private bool TryGetEnemyHealth(EnemyCandidate candidate, out float health, out float maxHealth)
        {
            health = 0f; maxHealth = 0f; bool hasHealth = false;
            foreach (object source in GetEnemyHealthSources(candidate))
            {
                if (source == null) continue;
                if (!hasHealth && TryReadFirstFloat(source, CurrentHealthMemberNames, out float cv)) { health = Math.Max(0f, cv); hasHealth = true; }
                if (maxHealth <= 0f && TryReadFirstFloat(source, MaxHealthMemberNames, out float mv)) maxHealth = Math.Max(0f, mv);
                if (hasHealth && maxHealth > 0f) break;
            }
            if (candidate.Root != null)
            {
                int stableId = GetStableEnemyId(candidate);
                if (clientSimulatedHealth.TryGetValue(stableId, out float simH)) { if (hasHealth && health < simH) clientSimulatedHealth[stableId] = health; else { health = simH; hasHealth = true; } }
            }
            if (!hasHealth && maxHealth > 0f) { health = maxHealth; return true; }
            return hasHealth;
        }
        private IEnumerable<object> GetEnemyHealthSources(EnemyCandidate candidate)
        {
            if (candidate.Root != null)
            {
                int rootId = candidate.Root.GetInstanceID();
                if (!healthSourcesByRootId.TryGetValue(rootId, out object[] cachedSources))
                {
                    var sources = new List<object>(); Component enemy = candidate.Root.GetComponent("Enemy");
                    object linkedHealth = ReadMember(enemy, "Health"); if (linkedHealth != null) sources.Add(linkedHealth);
                    Component enemyHealth = candidate.Root.GetComponent("EnemyHealth"); if (enemyHealth != null && !sources.Contains(enemyHealth)) sources.Add(enemyHealth);
                    if (enemy != null && !sources.Contains(enemy)) sources.Add(enemy);
                    cachedSources = sources.ToArray(); healthSourcesByRootId[rootId] = cachedSources;
                }
                foreach (var source in cachedSources) if (!(source is UnityEngine.Object obj && obj == null)) yield return source;
            }
            if (candidate.Component != null) yield return candidate.Component;
            Component enemyParent = GetEnemyParent(candidate); if (enemyParent != null) yield return enemyParent;
        }
        private static bool TryReadFirstFloat(object source, string[] memberNames, out float value) { foreach (string name in memberNames) { object raw = ReadMember(source, name); if (raw != null && TryConvertFloat(raw, out value)) return true; } value = 0f; return false; }
        private static Component GetEnemyParent(EnemyCandidate candidate) { if (candidate.Component != null && candidate.Component.GetType().Name == "EnemyParent") return candidate.Component; return ReadMember(candidate.Root == null ? null : candidate.Root.GetComponent("Enemy") ?? candidate.Component, "EnemyParent") as Component; }
        private static bool TryConvertFloat(object value, out float result) { try { result = Convert.ToSingle(value, CultureInfo.InvariantCulture); return true; } catch { result = 0f; return false; } }
        private static bool TryMarkEnemySent(int instanceId) { lock (enemyLock) { return sentEnemyInstanceIds.Add(instanceId); } }
        private static bool IsEnemySent(int instanceId) { lock (enemyLock) { return sentEnemyInstanceIds.Contains(instanceId); } }
        private void MarkMonsterSeen(string monsterName, EnemyCandidate candidate) { bool added = false; lock (seenLock) { if (!seenMonsters.Contains(monsterName)) { seenMonsters.Add(monsterName); added = true; } } if (added || ShouldLogSeen(monsterName)) lastSeenLoggedAt[monsterName] = Time.realtimeSinceStartup; }
        private bool ShouldLogSeen(string monsterName) { if (!debugLogging.Value) return false; if (!lastSeenLoggedAt.TryGetValue(monsterName, out float last)) return true; return Time.realtimeSinceStartup - last >= 30f; }
        private static bool IsNonGameplayLevelName(string levelName) { if (string.IsNullOrWhiteSpace(levelName)) return false; string lower = levelName.ToLowerInvariant(); return lower.Contains("lobby") || lower.Contains("menu") || lower.Contains("splash") || lower.Contains("post") || lower.Contains("death") || lower.Contains("result") || lower.Contains("summary") || lower.Contains("arena"); }
        private static bool IsNonGameplayContext() { object runManager = ReadMember(GetTypeCached("RunManager"), "instance"); return IsNonGameplayLevelName(DescribeLevelObject(ReadMember(runManager, "levelCurrent"))) || IsNonGameplayLevelName(SceneManager.GetActiveScene().name); }
        private static string DescribeCurrentLevel(object runManager) { return DescribeLevelObject(ReadMember(runManager, "levelCurrent")); }
        private static string DescribeLevelObject(object currentLevel) { if (currentLevel == null) return "<null>"; if (currentLevel is UnityEngine.Object unityObject) return string.IsNullOrWhiteSpace(unityObject.name) ? unityObject.ToString() : unityObject.name; return currentLevel.ToString(); }
        private static bool isRunLevelCache = false; private static float nextRunLevelCheck = 0f;
        private static bool CachedIsRunLevel(string sceneName) { if (sceneName != null) { if (IsNonGameplayLevelName(sceneName)) return false; if (IsRunLevelName(sceneName) || sceneName.ToLowerInvariant().Contains("shop")) return true; } if (Time.unscaledTime > nextRunLevelCheck) { object result = InvokeNoArgMethod(GetTypeCached("SemiFunc"), "RunIsLevel"); isRunLevelCache = (result is bool value && value) || SceneManager.GetActiveScene().name.ToLowerInvariant().Contains("shop"); nextRunLevelCheck = Time.unscaledTime + 1f; } return isRunLevelCache; }
        private static bool isMasterCache = false; private static float nextMasterCheck = 0f;
        private static bool CachedIsMasterClient() { if (Time.unscaledTime > nextMasterCheck) { object result = InvokeNoArgMethod(GetTypeCached("SemiFunc"), "IsMasterClientOrSingleplayer"); isMasterCache = result is bool value ? value : false; nextMasterCheck = Time.unscaledTime + 2f; } return isMasterCache; }
        private int ResolveCurrentLevel() { object runManager = ReadMember(GetTypeCached("RunManager"), "instance"); object levelsCompleted = ReadMember(runManager, "levelsCompleted"); if (levelsCompleted != null) { try { int level = Math.Max(1, Convert.ToInt32(levelsCompleted) + 1); fallbackLevel = level; return level; } catch { } } return fallbackLevel = Math.Max(1, lastSyncedLevel + 1); }
        private static bool IsRegularGameplayLevel() { object runManager = ReadMember(GetTypeCached("RunManager"), "instance"); object currentLevel = ReadMember(runManager, "levelCurrent"); object levelsValue = ReadMember(runManager, "levels"); if (currentLevel != null && levelsValue is IList levels && levels.Contains(currentLevel)) return true; if (IsNamedRunLevel(currentLevel)) return true; return CachedIsRunLevel(null); }
        private static bool IsGameplayLevelCandidate(out string details, bool allowExpensiveFallback = false)
        {
            object runManager = ReadMember(GetTypeCached("RunManager"), "instance"); object currentLevel = ReadMember(runManager, "levelCurrent"); object levelsValue = ReadMember(runManager, "levels");
            string currentLevelName = DescribeLevelObject(currentLevel); bool nonGameplayCurrent = IsNonGameplayLevelName(currentLevelName);
            bool listedLevel = !nonGameplayCurrent && currentLevel != null && levelsValue is IList levels && levels.Contains(currentLevel); bool namedLevel = IsNamedRunLevel(currentLevel);
            bool runLevel = !nonGameplayCurrent && CachedIsRunLevel(null); bool hasLevelGenerator = false;
            bool isShop = currentLevelName.ToLowerInvariant().Contains("shop") || SceneManager.GetActiveScene().name.ToLowerInvariant().Contains("shop");
            bool levelGenerated = IsLevelGenerated() || !CachedIsMasterClient() || isShop;
            string activeSceneName = SceneManager.GetActiveScene().name; bool nonGameplayScene = IsNonGameplayLevelName(activeSceneName); string activeNamedLevelObject = "";
            if (nonGameplayCurrent || nonGameplayScene) levelGenerated = false; else if (allowExpensiveFallback) { hasLevelGenerator = HasActiveLevelGenerator(); activeNamedLevelObject = FindActiveNamedRunLevelObject(); }
            details = "current=" + currentLevelName + ", generated=" + levelGenerated;
            if (nonGameplayCurrent || nonGameplayScene) return false;
            return levelGenerated && (listedLevel || namedLevel || runLevel || hasLevelGenerator || IsRunLevelName(activeSceneName) || isShop || !string.IsNullOrWhiteSpace(activeNamedLevelObject));
        }
        private static bool HasActiveLevelGenerator() { Type type = GetTypeCached("LevelGenerator"); if (type == null) return false; foreach (var generator in Resources.FindObjectsOfTypeAll(type)) if (generator is Component component && component.gameObject != null && component.gameObject.scene.IsValid()) return true; return false; }
        private static bool IsLevelGenerated() { Type type = GetTypeCached("LevelGenerator"); object levelGenerator = ReadMember(type, "Instance") ?? ReadMember(type, "instance"); return ReadMember(levelGenerator, "Generated") is bool value && value; }
        private static string FindActiveNamedRunLevelObject() { foreach (var obj in Resources.FindObjectsOfTypeAll(typeof(GameObject))) if (obj is GameObject go && go.scene.IsValid() && IsRunLevelName(go.name)) return go.name; return ""; }
        private static bool IsNamedRunLevel(object currentLevel) { return IsRunLevelName(DescribeLevelObject(currentLevel)); }
        private static bool IsRunLevelName(string levelName) { return !string.IsNullOrWhiteSpace(levelName) && levelName.StartsWith("Level - ", StringComparison.Ordinal) && !IsNonGameplayLevelName(levelName); }

        private void SyncPlayerUpgradesIfChanged(HashSet<string> onlyKeys = null)
        {
            object statsManager = ReadMember(GetTypeCached("StatsManager"), "instance"); if (statsManager == null) return;
            var aliveSteamIds = new HashSet<string>(); Type playerAvatarType = GetTypeCached("PlayerAvatar");
            if (playerAvatarType != null)
            {
                foreach (var avatar in Resources.FindObjectsOfTypeAll(playerAvatarType))
                {
                    if (avatar == null) continue; string id = ReadMember(avatar, "steamID") as string; if (string.IsNullOrEmpty(id)) continue;
                    bool dead = ReadMember(avatar, "isDead") is bool b && b;
                    object hpVal = ReadMember(avatar, "playerHealth"); if (hpVal != null && TryConvertFloat(hpVal, out float hp) && hp <= 0f) dead = true;
                    if (!dead) aliveSteamIds.Add(id);
                }
            }

            var currentUpgradesByPlayer = new Dictionary<string, Dictionary<string, int>>();
            bool anyChanged = false;

            for (int index = 0; index < TrackedPlayerUpgrades.Length; index++)
            {
                KeyValuePair<string, string> binding = TrackedPlayerUpgrades[index];
                if (!(ReadMember(statsManager, binding.Value) is IDictionary upgrades)) continue;

                foreach (DictionaryEntry entry in upgrades)
                {
                    string steamId = entry.Key?.ToString(); if (string.IsNullOrEmpty(steamId) || (aliveSteamIds.Count > 0 && !aliveSteamIds.Contains(steamId))) continue;
                    int value = 0; try { value = Math.Max(0, Convert.ToInt32(entry.Value)); } catch { continue; }

                    if (!currentUpgradesByPlayer.TryGetValue(steamId, out var playerUpgrades)) { playerUpgrades = new Dictionary<string, int>(); currentUpgradesByPlayer[steamId] = playerUpgrades; }
                    playerUpgrades[binding.Key] = value;

                    string cacheKey = steamId + "_" + binding.Key;
                    if (!lastSyncedUpgrades.TryGetValue(cacheKey, out int previousValue) || previousValue != value)
                    {
                        anyChanged = true;
                        lastSyncedUpgrades[cacheKey] = value;
                    }
                }
            }

            if (!anyChanged && onlyKeys == null) return;

            string localId = ResolveLocalPlayerSteamId();
            var json = new StringBuilder("{\"localSteamId\":\"").Append(localId ?? "").Append("\",\"players\":[");
            int playerCount = 0;

            foreach (var kvp in currentUpgradesByPlayer)
            {
                string steamId = kvp.Key; var playerUpgrades = kvp.Value;
                string playerName = ResolvePlayerName(steamId) ?? ("Player " + steamId.Substring(0, Math.Min(4, steamId.Length)));
                if (playerCount++ > 0) json.Append(',');
                json.Append("{\"steamId\":\"").Append(steamId).Append("\",\"name\":\"").Append(EscapeJson(playerName)).Append("\",\"upgrades\":{");
                int count = 0; foreach (var upg in playerUpgrades) { if (count++ > 0) json.Append(','); json.Append('\"').Append(upg.Key).Append("\":").Append(upg.Value); }
                json.Append("}}");
            }
            json.Append("]}");

            if (gameObject.activeInHierarchy) StartCoroutine(PostPlayerUpgrades(json.ToString(), playerCount));
        }

        private static string ResolvePlayerName(string steamId) { Type playerAvatarType = GetTypeCached("PlayerAvatar"); if (playerAvatarType == null) return null; foreach (var avatar in Resources.FindObjectsOfTypeAll(playerAvatarType)) { if ((ReadMember(avatar, "steamID") as string) == steamId) return ReadMember(avatar, "playerName") as string; } return null; }
        private static string ResolveLocalPlayerSteamId() { object playerController = ReadMember(GetTypeCached("PlayerController"), "instance"); string steamId = ReadMember(playerController, "playerSteamID") as string; return !string.IsNullOrEmpty(steamId) ? steamId : ReadMember(ReadMember(playerController, "playerAvatarScript"), "steamID") as string; }

        private static int ReadIntMember(object source, string memberName) { object value = ReadMember(source, memberName); if (value == null) return 0; try { return Convert.ToInt32(value, CultureInfo.InvariantCulture); } catch { return 0; } }
        private static float ReadFloatMember(object source, string memberName) { object value = ReadMember(source, memberName); if (value == null) return 0f; try { return Convert.ToSingle(value, CultureInfo.InvariantCulture); } catch { return 0f; } }
        private static object GetValuableSource(object source) { Component valuable = GetValuableComponent(source); return valuable != null ? valuable : source; }
        private static GameObject GetGameObject(object source) { if (source is GameObject gameObject) return gameObject; if (source is Component component) return component.gameObject; return null; }
        private static int GetUnityObjectId(object source) { return source is UnityEngine.Object unityObject ? unityObject.GetInstanceID() : 0; }
        private static bool ReferencesSameUnityObject(object left, object right) { int leftId = GetUnityObjectId(left); if (leftId == 0) return false; if (leftId == GetUnityObjectId(right)) return true; Component lv = GetValuableComponent(left), rv = GetValuableComponent(right); if (lv != null && rv != null && lv.GetInstanceID() == rv.GetInstanceID()) return true; GameObject lg = GetGameObject(left), rg = GetGameObject(right); return lg != null && rg != null && lg.GetInstanceID() == rg.GetInstanceID(); }
        private static int GetValuableKey(object source) { object valuable = GetValuableSource(source); if (valuable == null) return 0; object photonView = ReadMember(valuable, "photonView"); int photonViewId = ReadIntMember(photonView, "ViewID"); if (photonViewId > 0) return photonViewId; if (valuable is UnityEngine.Object unityObject) return unityObject.GetInstanceID(); return 0; }
        private static bool IsValuableInDollarHaul(object source) { int key = GetValuableKey(source); if (key != 0 && valuablesInDollarHaul.Contains(key)) return true; object roundDirector = ReadMember(GetTypeCached("RoundDirector"), "instance"); if (!(ReadMember(roundDirector, "dollarHaulList") is IEnumerable dollarHaulList)) return false; foreach (object item in dollarHaulList) { if (item == null) continue; int itemKey = GetValuableKey(item); if (key != 0 && itemKey == key) return true; if (ReferencesSameUnityObject(source, item)) return true; } return false; }
        private static void TrackDollarHaulValuable(object source, bool inHaul) { if (!CachedIsRunLevel(null)) return; int key = GetValuableKey(source); if (key == 0) return; if (inHaul) valuablesInDollarHaul.Add(key); else valuablesInDollarHaul.Remove(key); }
        private static float ReadValuableOriginalValue(object source) { return ReadFloatMember(GetValuableSource(source), "dollarValueOriginal"); }
        private static float ReadValuableCurrentValue(object source) { return ReadFloatMember(GetValuableSource(source), "dollarValueCurrent"); }
        private static Component GetValuableComponent(object source) { if (source is Component component) { Component val = component.GetComponent("ValuableObject"); if (val != null) return val; } if (source is GameObject gameObject) return gameObject.GetComponent("ValuableObject"); return null; }
        private static int? ResolveExtractionGoal() { object roundDirector = ReadMember(GetTypeCached("RoundDirector"), "instance"); object goal = ReadMember(roundDirector, "extractionHaulGoal"); if (goal == null) return null; try { return Math.Max(0, Convert.ToInt32(goal)); } catch { return null; } }
        private static float CalculateMapValue() { Type valuableType = GetTypeCached("ValuableObject"); if (valuableType == null) return 0f; float total = 0f; foreach (var val in UnityEngine.Object.FindObjectsOfType(valuableType)) total += ReadValuableCurrentValue(val); return Math.Max(0f, total); }
        private string ResolveCurrentLevelName() { object currentLevel = ReadMember(ReadMember(GetTypeCached("RunManager"), "instance"), "levelCurrent"); string levelName = DescribeLevelObject(currentLevel); return levelName == "<null>" ? "" : levelName; }
        private void SyncLevelToOverlay(int level, string levelName) { lastSyncedLevel = level; if (gameObject.activeInHierarchy) StartCoroutine(PostLevel(level, levelName)); lastSyncedUpgrades.Clear(); pendingUpgradeKeys.Clear(); for (int index = 0; index < TrackedPlayerUpgrades.Length; index++) pendingUpgradeKeys.Add(TrackedPlayerUpgrades[index].Key); nextUpgradeSyncAt = Time.realtimeSinceStartup + 2f; }
        private static Camera FindBestCamera() { if (Camera.main != null) return Camera.main; Camera best = null; float bestDepth = float.MinValue; foreach (Camera camera in Camera.allCameras) { if (camera == null || !camera.isActiveAndEnabled) continue; if (camera.depth >= bestDepth) { best = camera; bestDepth = camera.depth; } } return best; }
        private List<EnemyCandidate> FindEnemyCandidates() { var result = new List<EnemyCandidate>(); var seenRoots = new HashSet<int>(); foreach (Component component in GetKnownEnemyParentsSnapshot()) AddEnemyCandidate(result, seenRoots, component); foreach (Component component in FindSpawnedEnemiesFromDirector()) AddEnemyCandidate(result, seenRoots, component); float now = Time.realtimeSinceStartup; bool runBroadDiscovery = !rosterPublished && result.Count == 0 && broadEnemyDiscoveryAttempts < 3 && now >= nextBroadEnemyDiscoveryAt; if (runBroadDiscovery) { broadEnemyDiscoveryAttempts++; nextBroadEnemyDiscoveryAt = now + 5f; foreach (Component component in FindComponentsByTypeName("EnemyParent")) AddEnemyCandidate(result, seenRoots, component); if (result.Count == 0) foreach (Component component in FindComponentsByTypeName("Enemy")) AddEnemyCandidate(result, seenRoots, component); } return result; }
        private static void RegisterEnemyParent(Component component) { if (component == null) return; lock (enemyLock) { knownEnemyParents.RemoveAll((enemy) => enemy == null); if (!knownEnemyParents.Contains(component)) { knownEnemyParents.Add(component); if (Plugin.instance != null) { Plugin.instance.enemyRosterDirty = true; Plugin.instance.nextScanAt = 0f; } } } }
        private static List<Component> GetKnownEnemyParentsSnapshot() { lock (enemyLock) { knownEnemyParents.RemoveAll((enemy) => enemy == null); return new List<Component>(knownEnemyParents); } }
        private static IEnumerable<Component> FindSpawnedEnemiesFromDirector(bool allowExpensiveFallback = false) { Type directorType = GetTypeCached("EnemyDirector"); if (directorType == null) yield break; object instance = ReadMember(directorType, "instance"); if (instance != null) { foreach (Component component in EnumerateSpawnedEnemies(instance)) yield return component; yield break; } if (!allowExpensiveFallback) yield break; foreach (UnityEngine.Object director in Resources.FindObjectsOfTypeAll(directorType)) foreach (Component component in EnumerateSpawnedEnemies(director)) yield return component; }
        private static IEnumerable<Component> EnumerateSpawnedEnemies(object director) { object spawned = ReadMember(director, "enemiesSpawned"); if (!(spawned is IEnumerable enumerable)) yield break; foreach (object item in enumerable) if (item is Component component) yield return component; }
        private static IEnumerable<Component> FindComponentsByTypeName(string typeName) { Type type = Type.GetType(typeName + ", Assembly-CSharp"); if (type == null || !typeof(Component).IsAssignableFrom(type)) yield break; foreach (UnityEngine.Object obj in Resources.FindObjectsOfTypeAll(type)) if (obj is Component component) yield return component; }
        private static void AddEnemyCandidate(List<EnemyCandidate> result, HashSet<int> seenRoots, Component component) { if (component == null) return; GameObject root = GetEnemyRoot(component); if (root == null || !root.activeInHierarchy) return; Component enemyParent = component.GetType().Name == "EnemyParent" ? component : ReadMember(component, "EnemyParent") as Component; if (enemyParent != null) RegisterEnemyParent(enemyParent); int id = root.GetInstanceID(); if (!seenRoots.Add(id)) return; result.Add(new EnemyCandidate { Component = component, Root = root, Center = GetObjectCenter(root) }); }
        private static bool LooksLikeEnemyComponent(Component component) { string typeName = component.GetType().Name; if (typeName == "EnemyParent" || typeName == "Enemy" || typeName == "EnemyAvatar") return true; if (typeName.StartsWith("Enemy", StringComparison.OrdinalIgnoreCase)) return true; return FindKnownMonster(component.gameObject.name) != null; }
        private static GameObject GetEnemyRoot(Component component) { if (component.GetType().Name == "Enemy") return component.gameObject; if (component.GetType().Name == "EnemyParent") { object linkedEnemy = ReadMember(component, "Enemy"); return linkedEnemy is Component enemyComponent ? enemyComponent.gameObject : null; } return component.gameObject; }
        private static Vector3 GetObjectCenter(GameObject root) { Component enemy = root.GetComponent("Enemy"); if (enemy != null) { object centerTransform = ReadMember(enemy, "CenterTransform"); if (centerTransform is Transform transform) return transform.position; } Renderer renderer = root.GetComponentInChildren<Renderer>(); if (renderer != null) return renderer.bounds.center; Collider collider = root.GetComponentInChildren<Collider>(); if (collider != null) return collider.bounds.center; return root.transform.position + Vector3.up; }
        private static string ResolveMonsterName(Component component) { if (component == null) return null; Component enemyParent = component.GetType().Name == "EnemyParent" ? component : ReadMember(component, "EnemyParent") as Component; if (enemyParent == null) return null; return FindKnownMonster(ReadMember(enemyParent, "enemyName") as string); }
        private static bool ShouldUseLegacyVisionFallback(Component enemyParent) { string monsterName = ResolveMonsterName(enemyParent); return monsterName != null && PlayerVisionLegacyFallbackMonsters.Contains(monsterName); }
        private static bool IsEnemyParentPlayerClose(Component enemyParent) { return ReadMember(enemyParent, "playerClose") is bool b && b; }
        private static bool IsEnemyParentPlayerVeryClose(Component enemyParent) { return ReadMember(enemyParent, "playerVeryClose") is bool b && b; }
        private bool IsEnemyOnScreenVisible(Component enemyOnScreen) { return ReadMember(enemyOnScreen, "OnScreenLocal") is bool isOnScreen && isOnScreen && (!(ReadMember(enemyOnScreen, "CulledLocal") is bool isCulled) || !isCulled); }

        private void HandleBlindEnemyPlayerVeryClose(Component enemyParent) { if (enemyParent == null || HasEnemyVision(enemyParent)) return; if (preferPlayerVisionDetection.Value && HasEnemyOnScreen(enemyParent) && !ShouldUseLegacyVisionFallback(enemyParent)) return; var candidate = new EnemyCandidate { Component = enemyParent, Root = GetEnemyRoot(enemyParent) }; int stableId = GetStableEnemyId(candidate); if (stableId == 0 || IsEnemySent(stableId)) return; RegisterEnemyParent(enemyParent); string monsterName = null; if (PublishEnemyParentEncounter(enemyParent, ref stableId, ref monsterName)) return; pendingEncounterIds.Add(stableId); enemyRosterDirty = true; nextScanAt = 0f; }
        private void HandleEnemyOnScreenVisible(Component enemyParent, ref int stableId) { if (!preferPlayerVisionDetection.Value || enemyParent == null) return; if (stableId == 0) stableId = GetStableEnemyId(new EnemyCandidate { Component = enemyParent, Root = GetEnemyRoot(enemyParent) }); if (stableId == 0 || IsEnemySent(stableId)) return; RegisterEnemyParent(enemyParent); string monsterName = null; if (PublishEnemyParentEncounter(enemyParent, ref stableId, ref monsterName)) return; pendingEncounterIds.Add(stableId); enemyRosterDirty = true; nextScanAt = 0f; }
        private bool PublishEnemyParentEncounter(Component enemyParent, ref int stableId, ref string monsterName)
        {
            if (!rosterPublished || enemyParent == null) return false; GameObject root = GetEnemyRoot(enemyParent); if (root == null) return false;
            var candidate = new EnemyCandidate { Component = enemyParent, Root = root, Center = GetObjectCenter(root) };
            if (stableId == 0) stableId = GetStableEnemyId(candidate);
            if (stableId == 0 || IsEnemySent(stableId)) return true;
            if (monsterName == null) { monsterName = ResolveMonsterName(enemyParent); if (monsterName != null) resolvedMonsterNames[stableId] = monsterName; }
            if (monsterName == null) return false;
            if (!TryMarkEnemySent(stableId)) return true;
            MarkMonsterSeen(monsterName, candidate);
            if (gameObject.activeInHierarchy) StartCoroutine(PostSeenMonster(monsterName, stableId));

            int viewId = GetEnemyViewId(enemyParent, root.GetInstanceID());
            if (viewId != 0) SendOverlayEvent(new object[] { "SPOT", viewId, monsterName });

            SyncEnemyParentStatusChanged(enemyParent); return true;
        }
        private void HandleEnemyVisionTrigger(object vision, int playerId) { if (!gameplayActive || vision == null || playerId != GetLocalPlayerViewId()) return; if (!TryGetVisionEnemyCache(vision, out VisionEnemyCache visionEnemy)) return; Component enemyParent = visionEnemy.EnemyParent; if (preferPlayerVisionDetection.Value && HasEnemyOnScreen(enemyParent) && !ShouldUseLegacyVisionFallback(enemyParent)) return; int stableId = visionEnemy.StableId; if (stableId == 0 || IsEnemySent(stableId) || pendingEncounterIds.Contains(stableId)) return; RegisterEnemyParent(enemyParent); string monsterName = null; if (PublishEnemyParentEncounter(enemyParent, ref stableId, ref monsterName)) { pendingEncounterIds.Remove(stableId); return; } pendingEncounterIds.Add(stableId); enemyRosterDirty = true; nextScanAt = 0f; }
        private bool TryGetVisionEnemyCache(object vision, out VisionEnemyCache visionEnemy) { visionEnemy = default; int visionId = GetUnityObjectId(vision); if (visionId != 0 && visionEnemyCacheByVisionId.TryGetValue(visionId, out visionEnemy) && visionEnemy.EnemyParent != null && visionEnemy.StableId != 0) return true; Component enemy = ReadMember(vision, "Enemy") as Component; Component enemyParent = ReadMember(enemy, "EnemyParent") as Component; if (enemyParent == null) return false; int stableId = GetStableEnemyId(new EnemyCandidate { Component = enemyParent, Root = GetEnemyRoot(enemyParent) }); if (stableId == 0) return false; visionEnemy = new VisionEnemyCache { EnemyParent = enemyParent, StableId = stableId }; if (visionId != 0) visionEnemyCacheByVisionId[visionId] = visionEnemy; return true; }
        private void TryPublishPendingVisionEncounters(List<ResolvedEnemyCandidate> resolvedEnemies) { if (pendingEncounterIds.Count == 0) return; foreach (var resolvedEnemy in resolvedEnemies) { int stableId = GetStableEnemyId(resolvedEnemy.Candidate); if (!pendingEncounterIds.Contains(stableId)) continue; Component enemyParent = GetEnemyParent(resolvedEnemy.Candidate); string monsterName = resolvedEnemy.MonsterName; int publishId = stableId; if (PublishEnemyParentEncounter(enemyParent, ref publishId, ref monsterName)) pendingEncounterIds.Remove(stableId); } }
        private static bool HasEnemyVision(Component enemyParent) { if (enemyParent == null) return false; Plugin plugin = instance; if (plugin != null) { int parentId = enemyParent.GetInstanceID(); if (plugin.enemyHasVisionByParentId.TryGetValue(parentId, out bool cachedValue)) return cachedValue; bool value = ReadEnemyHasVision(enemyParent); plugin.enemyHasVisionByParentId[parentId] = value; return value; } return ReadEnemyHasVision(enemyParent); }
        private static bool ReadEnemyHasVision(Component enemyParent) { return ReadMember(ReadMember(enemyParent, "Enemy") as Component, "HasVision") is bool b && b; }
        private static bool HasEnemyOnScreen(Component enemyParent) { if (enemyParent == null) return false; Plugin plugin = instance; if (plugin != null) { int parentId = enemyParent.GetInstanceID(); if (plugin.enemyHasOnScreenByParentId.TryGetValue(parentId, out bool cachedValue)) return cachedValue; bool value = ReadEnemyHasOnScreen(enemyParent); plugin.enemyHasOnScreenByParentId[parentId] = value; return value; } return ReadEnemyHasOnScreen(enemyParent); }
        private static bool ReadEnemyHasOnScreen(Component enemyParent) { Component enemy = ReadMember(enemyParent, "Enemy") as Component; if (ReadMember(enemy, "HasOnScreen") is bool value) return value; return enemy != null && enemy.GetComponent("EnemyOnScreen") != null; }
        private static Component GetEnemyParentFromOnScreen(Component enemyOnScreen) { if (enemyOnScreen == null) return null; Component enemy = ReadMember(enemyOnScreen, "Enemy") as Component; if (enemy == null) enemy = enemyOnScreen.GetComponent("Enemy"); return ReadMember(enemy, "EnemyParent") as Component; }
        private int GetLocalPlayerViewId() { if (cachedLocalPlayerViewId != int.MinValue) return cachedLocalPlayerViewId; cachedLocalPlayerViewId = ResolveLocalPlayerViewId(); return cachedLocalPlayerViewId; }
        private static int ResolveLocalPlayerViewId() { object localViewId = InvokeNoArgMethod(GetTypeCached("SemiFunc"), "PhotonViewIDPlayerAvatarLocal"); if (localViewId != null) try { return Convert.ToInt32(localViewId, CultureInfo.InvariantCulture); } catch { } object player = InvokeNoArgMethod(GetTypeCached("SemiFunc"), "PlayerAvatarLocal"); if (player == null) player = ReadMember(GetTypeCached("PlayerAvatar"), "instance"); return ReadIntMember(ReadMember(player, "photonView"), "ViewID"); }

        private static object ReadMember(object source, string memberName)
        {
            if (source == null) return null; Type type = source as Type ?? source.GetType();
            if (!fastMemberCache.TryGetValue(type, out var typeCache)) { typeCache = new Dictionary<string, MemberInfo>(); fastMemberCache[type] = typeCache; }
            if (!typeCache.TryGetValue(memberName, out var member))
            {
                member = type.GetField(memberName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static) as MemberInfo ?? type.GetProperty(memberName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
                typeCache[memberName] = member;
            }
            if (member == null) return null;
            if (member is FieldInfo field) return (!field.IsStatic && source is Type) ? null : field.GetValue(field.IsStatic ? null : source);
            if (member is PropertyInfo property && property.CanRead) { var getter = property.GetGetMethod(true); return (getter != null && (getter.IsStatic || !(source is Type))) ? property.GetValue(getter.IsStatic ? null : source, null) : null; }
            return null;
        }

        private static object InvokeNoArgMethod(object source, string methodName)
        {
            if (source == null) return null; Type type = source as Type ?? source.GetType();
            if (!fastNoArgMethodCache.TryGetValue(type, out var typeCache)) { typeCache = new Dictionary<string, MethodInfo>(); fastNoArgMethodCache[type] = typeCache; }
            if (!typeCache.TryGetValue(methodName, out var method))
            {
                method = type.GetMethod(methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static, null, Type.EmptyTypes, null);
                typeCache[methodName] = method;
            }
            if (method == null || (!method.IsStatic && source is Type)) return null;
            try { return method.Invoke(method.IsStatic ? null : source, null); } catch { return null; }
        }

        private static Task<string> QueueNetworkRequest(Func<string> request) { lock (networkQueueLock) { Task<string> queued = networkQueueTail.ContinueWith(_ => request(), CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default); networkQueueTail = queued; return queued; } }
        private IEnumerator PostSeenMonster(string monsterName, int instanceId) { Task<string> req = QueueNetworkRequest(() => SendHttpPost(endpoint.Value, "{\"name\":\"" + EscapeJson(monsterName) + "\",\"id\":" + instanceId + "}")); while (!req.IsCompleted) yield return null; }
        private IEnumerator PostMonsterRoster(string json) { Task<string> req = QueueNetworkRequest(() => SendHttpPost(BuildSiblingEndpoint(levelEndpoint.Value, "/api/roster"), json)); while (!req.IsCompleted) yield return null; }
        private IEnumerator PostMonsterStatuses(string json, bool coalesce = false) { int reqVer = coalesce ? Interlocked.Increment(ref latestMonsterStatusRequestVersion) : 0; Task<string> req = QueueNetworkRequest(() => !coalesce || reqVer == Volatile.Read(ref latestMonsterStatusRequestVersion) ? SendHttpPost(BuildSiblingEndpoint(levelEndpoint.Value, "/api/monster-status"), json) : "SKIPPED:Superseded monster status snapshot."); while (!req.IsCompleted) yield return null; }
        private IEnumerator PostLevel(int level, string levelName) { Task<string> req = QueueNetworkRequest(() => SendHttpPost(levelEndpoint.Value, "{\"level\":" + level + ",\"levelName\":\"" + EscapeJson(levelName ?? "") + "\"}")); while (!req.IsCompleted) yield return null; }
        private IEnumerator PostVisibility(bool visible) { Task<string> req = QueueNetworkRequest(() => SendHttpPost(BuildSiblingEndpoint(levelEndpoint.Value, "/api/visibility"), "{\"visible\":" + (visible ? "true" : "false") + "}")); while (!req.IsCompleted) yield return null; }
        private IEnumerator PostCursorState(bool visible) { Task<string> req = QueueNetworkRequest(() => SendHttpPost(BuildSiblingEndpoint(levelEndpoint.Value, "/api/cursor"), "{\"visible\":" + (visible ? "true" : "false") + "}")); while (!req.IsCompleted) yield return null; }
        private IEnumerator PostTabHidden(bool hidden) { Task<string> req = QueueNetworkRequest(() => SendHttpPost(BuildSiblingEndpoint(levelEndpoint.Value, "/api/tab-hidden"), "{\"hidden\":" + (hidden ? "true" : "false") + "}")); while (!req.IsCompleted) yield return null; }
        private IEnumerator PostPlayerUpgrades(string json, int changedCount) { Task<string> req = QueueNetworkRequest(() => SendHttpPost(BuildSiblingEndpoint(levelEndpoint.Value, "/api/upgrades"), json)); while (!req.IsCompleted) yield return null; }
        private IEnumerator PostMapValue(int value, int initial, int lost, int? goal) { string json = "{\"value\":" + value.ToString(CultureInfo.InvariantCulture) + ",\"initial\":" + initial.ToString(CultureInfo.InvariantCulture) + ",\"lost\":" + lost.ToString(CultureInfo.InvariantCulture); if (goal.HasValue) json += ",\"goal\":" + goal.Value.ToString(CultureInfo.InvariantCulture); json += "}"; int reqVer = Interlocked.Increment(ref latestMapValueRequestVersion); Task<string> req = QueueNetworkRequest(() => reqVer == Volatile.Read(ref latestMapValueRequestVersion) ? SendHttpPost(BuildSiblingEndpoint(levelEndpoint.Value, "/api/map-value"), json) : "SKIPPED:Superseded map value snapshot."); while (!req.IsCompleted) yield return null; }

        private static string SendStateLevelFallback(int level, string levelEndpointUrl) { string stateEndpoint = BuildSiblingEndpoint(levelEndpointUrl, "/api/state"); return SendHttpPost(stateEndpoint, "{\"state\":" + BuildFallbackStateJson(level, SendHttpGet(stateEndpoint)) + "}"); }
        private static string BuildSiblingEndpoint(string endpointUrl, string path) { try { var uri = new Uri(endpointUrl); return uri.Scheme + "://" + uri.Host + (uri.IsDefaultPort ? "" : ":" + uri.Port) + path; } catch { return endpointUrl.Replace("/api/level", path).Replace("/api/monster-seen", path); } }
        private static string BuildFallbackStateJson(int level, string getStateResult) { string stateObject = ExtractJsonObjectProperty(getStateResult, "state"); if (string.IsNullOrWhiteSpace(stateObject)) stateObject = "{}"; stateObject = SetJsonNumberProperty(stateObject, "level", level); stateObject = SetJsonBooleanProperty(stateObject, "gameplayVisible", true); stateObject = SetJsonNumberProperty(stateObject, "seconds", 0); stateObject = SetJsonBooleanProperty(stateObject, "running", true); stateObject = SetJsonRawProperty(stateObject, "startedAt", ((long)(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalMilliseconds).ToString(CultureInfo.InvariantCulture)); stateObject = SetJsonRawProperty(stateObject, "monsters", "[]"); stateObject = SetJsonNumberProperty(stateObject, "mapValue", 0); stateObject = SetJsonNumberProperty(stateObject, "mapValueInitial", 0); stateObject = SetJsonRawProperty(stateObject, "mapValueGoal", "null"); stateObject = SetJsonNumberProperty(stateObject, "lostValue", 0); return stateObject; }
        private static string SetJsonNumberProperty(string json, string name, int value) { return SetJsonRawProperty(json, name, value.ToString()); }
        private static string SetJsonBooleanProperty(string json, string name, bool value) { return SetJsonRawProperty(json, name, value ? "true" : "false"); }
        private static string SetJsonRawProperty(string json, string name, string value) { string pattern = "(\"" + Regex.Escape(name) + "\"\\s*:\\s*)(null|true|false|-?\\d+(?:\\.\\d+)?|\"(?:\\\\.|[^\"])*\"|\\[[\\s\\S]*?\\]|\\{[\\s\\S]*?\\})"; var regex = new Regex(pattern); if (regex.IsMatch(json)) return regex.Replace(json, "$1" + value, 1); string trimmed = string.IsNullOrWhiteSpace(json) ? "{}" : json.Trim(); if (trimmed == "{}") return "{\"" + name + "\":" + value + "}"; return trimmed.Substring(0, trimmed.Length - 1) + ",\"" + name + "\":" + value + "}"; }
        private static string ExtractJsonObjectProperty(string json, string name) { if (string.IsNullOrWhiteSpace(json)) return null; int markerIndex = json.IndexOf("\"" + name + "\"", StringComparison.Ordinal); if (markerIndex < 0) return null; int colonIndex = json.IndexOf(':', markerIndex + name.Length + 2); if (colonIndex < 0) return null; int start = json.IndexOf('{', colonIndex + 1); if (start < 0) return null; int depth = 0; bool inString = false, escaped = false; for (int index = start; index < json.Length; index++) { char ch = json[index]; if (escaped) { escaped = false; continue; } if (ch == '\\' && inString) { escaped = true; continue; } if (ch == '"') { inString = !inString; continue; } if (inString) continue; if (ch == '{') depth++; else if (ch == '}') { depth--; if (depth == 0) return json.Substring(start, index - start + 1); } } return null; }

        private static string SendHttpPost(string endpointUrl, string json)
        {
            try
            {
                var request = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(endpointUrl);
                request.Method = "POST"; request.ContentType = "application/json"; request.KeepAlive = true; request.Timeout = 2000;
                byte[] body = Encoding.UTF8.GetBytes(json); request.ContentLength = body.Length;
                using (Stream stream = request.GetRequestStream()) { stream.Write(body, 0, body.Length); }
                using (var response = (System.Net.HttpWebResponse)request.GetResponse())
                using (var reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8)) { return reader.ReadToEnd(); }
            }
            catch (Exception error) { return "ERROR:" + error.GetType().Name + ": " + error.Message; }
        }


        private static string SendHttpGet(string endpointUrl)
        {
            try
            {
                var request = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(endpointUrl);
                request.Method = "GET"; request.KeepAlive = true; request.Timeout = 2000;
                using (var response = (System.Net.HttpWebResponse)request.GetResponse())
                using (var reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8)) { return reader.ReadToEnd(); }
            }
            catch (Exception error) { return "ERROR:" + error.GetType().Name + ": " + error.Message; }
        }

        private static string FindKnownMonster(string raw) { string key = Normalize(raw); foreach (KeyValuePair<string, string> pair in KnownMonsters) if (key.Contains(pair.Key)) return pair.Value; return null; }
        private static string Normalize(string value) { if (string.IsNullOrWhiteSpace(value)) return ""; var builder = new StringBuilder(value.Length); foreach (char ch in value.ToLowerInvariant()) if ((ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')) builder.Append(ch); return builder.ToString(); }
        private static string EscapeJson(string value) { return value.Replace("\\", "\\\\").Replace("\"", "\\\""); }

        private struct EnemyCandidate { public Component Component; public GameObject Root; public Vector3 Center; }
        private struct ResolvedEnemyCandidate { public EnemyCandidate Candidate; public string MonsterName; }
        private struct VisionEnemyCache { public Component EnemyParent; public int StableId; }
    }
}